cloudFPGA (cF) API  1.0
The documentation of the source code of cloudFPGA (cF)
Public Member Functions | List of all members
SimEthFrame Class Reference
cF » cFSphere » cFDK » SHELL Library » NTS » SimNts

Class ETHERNET Frame. More...

#include <SimEthFrame.hpp>

Public Member Functions

 SimEthFrame (int frmLen)
 
 SimEthFrame ()
 
void pushChunk (AxisEth ethChunk)
 
AxisEth pullChunk ()
 
int length ()
 
int size ()
 
void setMacDestinAddress (EthAddr addr)
 
EthAddr getMacDestinAddress ()
 
LE_EthAddr getLE_MacDestinAddress ()
 
void setMacSourceAddress (EthAddr addr)
 
EthAddr getMacSourceAddress ()
 
void setTypeLength (EthTypeLen typLen)
 
EthTypeLen getTypeLength ()
 
int sizeOfPayload ()
 
SimIp4Packet getIpPacket ()
 
SimArpPacket getArpPacket ()
 
bool addPayload (SimArpPacket arpPkt)
 Add data payload to this frame from an ARP packet. More...
 
bool addPayload (SimIp4Packet ipPkt)
 Add data payload to this frame from an IP4 packet. More...
 
bool writeToDatFile (ofstream &outFileStream)
 Dump this Ethernet frame as raw AxisEth chunks into a file. More...
 

Detailed Description

Class ETHERNET Frame.

This class defines an ETHERNET frame as a set of 'AxisEth' data chunks. Such an ETHERNET frame consists of a double-ended queue that is used to accumulate all these data chunks. For the 10GbE MAC, the IPv4 chunks are 64 bits wide.

Usage: EthFrame(int frmLen) Constructs a frame consisting of 'frmLen' bytes. EthFrame() Constructs a frame of 12 bytes to hold the Ethernet header.

Definition at line 55 of file SimEthFrame.hpp.

Constructor & Destructor Documentation

◆ SimEthFrame() [1/2]

SimEthFrame::SimEthFrame ( int  frmLen)
inline

Definition at line 91 of file SimEthFrame.hpp.

91  {
92  this->myName = "SimEthFrame";
93  setLen(0);
94  if (frmLen > 0 && frmLen <= MTU) {
95  int noBytes = frmLen;
96  while(noBytes > 8) {
97  pushChunk(AxisEth(0x0000000000000000, 0xFF, 0));
98  noBytes -= 8;
99  }
100  pushChunk(AxisEth(0x0000000000000000, lenToLE_tKeep(noBytes), TLAST));
101  }
102  }
SimEthFrame::pushChunk
void pushChunk(AxisEth ethChunk)
Definition: SimEthFrame.hpp:109
lenToLE_tKeep
LE_tKeep lenToLE_tKeep(ap_uint< 4 > noValidBytes)
A function to set a number of '1' in an 8-bit field. It is used here to set the number of valid bytes...
Definition: nts_utils.cpp:307
TLAST
#define TLAST
Definition: AxisRaw.hpp:116
MTU
#define MTU
Definition: udp.hpp:71
Here is the call graph for this function:

◆ SimEthFrame() [2/2]

SimEthFrame::SimEthFrame ( )
inline

Definition at line 103 of file SimEthFrame.hpp.

103  {
104  this->myName = "SimEthFrame";
105  setLen(0);
106  }

Member Function Documentation

◆ addPayload() [1/2]

bool SimEthFrame::addPayload ( SimArpPacket  arpPkt)
inline

Add data payload to this frame from an ARP packet.

Warning
The frame object must be of length 14 bytes (.i.e {MA_DA, MAC_SA, ETHERTYPE}
Parameters
[in]arpPktThe ARP packet to use as Ethernet payload.
Returns
true upon success, otherwise false.

Definition at line 314 of file SimEthFrame.hpp.

314  {
315  bool alternate = true;
316  bool endOfPkt = false;
317  AxisArp arpChunk(0,0,0);
318  LE_tData newTData = 0;
319  LE_tKeep newTKeep = 0;
320  LE_tLast newTLast = 0;
321  int arpChunkCnt = 0;
322  int ethChunkCnt = 1; // Start from 1st chunk which contains ETHER_TYP and MAC_SA [5:2]
323 
324  if (this->getLen() != 14) {
325  printError(this->myName, "Frame is expected to be of length 14 bytes (was found to be %d bytes).\n", this->getLen());
326  return false;
327  }
328  // Read and pop the very first chunk from the packet
329  arpChunk = arpPkt.pullChunk();
330 
331  while (!endOfPkt) {
332  if (alternate) {
333  if (arpChunk.getLE_TKeep() & 0x01) {
334  this->frmQ[ethChunkCnt].setLE_TData(arpChunk.getLE_TData().range( 7, 0), 55, 48);
335  this->frmQ[ethChunkCnt].setLE_TKeep(this->frmQ[ethChunkCnt].getLE_TKeep() | (0x40));
336  this->setLen(this->getLen() + 1);
337  }
338  if (arpChunk.getLE_TKeep() & 0x02) {
339  this->frmQ[ethChunkCnt].setLE_TData(arpChunk.getLE_TData().range(15, 8), 63, 56);
340  this->frmQ[ethChunkCnt].setLE_TKeep(this->frmQ[ethChunkCnt].getLE_TKeep() | (0x80));
341  this->setLen(this->getLen() + 1);
342  }
343  if ((arpChunk.getLE_TLast()) && (arpChunk.getLE_TKeep() <= 0x03)) {
344  this->frmQ[ethChunkCnt].setLE_TLast(TLAST);
345  endOfPkt = true;
346  }
347  else {
348  this->frmQ[ethChunkCnt].setLE_TLast(0);
349  }
350  alternate = !alternate;
351  }
352  else {
353  // Build a new chunk and add it to the queue
354  AxisEth newEthChunk(0, 0, 0);
355  if (arpChunk.getLE_TKeep() & 0x04) {
356  newEthChunk.setLE_TData(arpChunk.getLE_TData().range(23, 16), 7, 0);
357  newEthChunk.setLE_TKeep(newEthChunk.getLE_TKeep() | (0x01));
358  }
359  if (arpChunk.getLE_TKeep() & 0x08) {
360  newEthChunk.setLE_TData(arpChunk.getLE_TData().range(31, 24), 15, 8);
361  newEthChunk.setLE_TKeep(newEthChunk.getLE_TKeep() | (0x02));
362  }
363  if (arpChunk.getLE_TKeep() & 0x10) {
364  newEthChunk.setLE_TData(arpChunk.getLE_TData().range(39, 32), 23,16);
365  newEthChunk.setLE_TKeep(newEthChunk.getLE_TKeep() | (0x04));
366  }
367  if (arpChunk.getLE_TKeep() & 0x20) {
368  newEthChunk.setLE_TData(arpChunk.getLE_TData().range(47, 40), 31,24);
369  newEthChunk.setLE_TKeep(newEthChunk.getLE_TKeep() | (0x08));
370  }
371  if (arpChunk.getLE_TKeep() & 0x40) {
372  newEthChunk.setLE_TData(arpChunk.getLE_TData().range(55, 48), 39,32);
373  newEthChunk.setLE_TKeep(newEthChunk.getLE_TKeep() | (0x10));
374  }
375  if (arpChunk.getLE_TKeep() & 0x80) {
376  newEthChunk.setLE_TData(arpChunk.getLE_TData().range(63, 56), 47,40);
377  newEthChunk.setLE_TKeep(newEthChunk.getLE_TKeep() | (0x20));
378  }
379  // Done with the incoming IP Chunk
380  arpChunkCnt++;
381  if (arpChunk.getLE_TLast()) {
382  newEthChunk.setLE_TLast(TLAST);
383  endOfPkt = true;
384  this->pushChunk(newEthChunk);
385  }
386  else {
387  newEthChunk.setLE_TLast(0);
388  this->pushChunk(newEthChunk);
389  ethChunkCnt++;
390  // Read and pop a new chunk from the packet
391  arpChunk = arpPkt.pullChunk();
392  }
393  alternate = !alternate;
394  }
395  } // End-of while(!endOfPkt)
396  return true;
397  }
SimArpPacket::pullChunk
AxisArp pullChunk()
Definition: SimArpPacket.hpp:113
printError
#define printError(callerName, format,...)
A macro to print an error message.
Definition: nts_utils.hpp:195
LE_tData
ap_uint< 64 > LE_tData
Definition: AxisRaw.hpp:122
LE_tKeep
ap_uint< 64/8 > LE_tKeep
Definition: AxisRaw.hpp:124
LE_tLast
ap_uint< 1 > LE_tLast
Definition: AxisRaw.hpp:125
Here is the call graph for this function:
Here is the caller graph for this function:

◆ addPayload() [2/2]

bool SimEthFrame::addPayload ( SimIp4Packet  ipPkt)
inline

Add data payload to this frame from an IP4 packet.

Warning
The frame object must be of length 14 bytes (.i.e {MA_DA, MAC_SA, ETHERTYPE}
Parameters
[in]ipPktThe IPv4 packet to use as Ethernet payload.
Returns
true upon success, otherwise false.

Definition at line 408 of file SimEthFrame.hpp.

408  {
409  bool alternate = true;
410  bool endOfPkt = false;
411  AxisIp4 ip4Chunk(0, 0, 0);
412  int ip4ChunkCnt = 0;
413  int ethChunkCnt = 1; // Start from 1st chunk which contains ETHER_TYP and MAC_SA [5:2]
414 
415  if (this->getLen() != 14) {
416  printError(this->myName, "Frame is expected to be of length 14 bytes (was found to be %d bytes).\n", this->getLen());
417  return false;
418  }
419  // Read and pop the very first chunk from the packet
420  ip4Chunk = ipPkt.pullChunk();
421  while (!endOfPkt) {
422  if (alternate) {
423  if (ip4Chunk.getLE_TKeep() & 0x01) {
424  this->frmQ[ethChunkCnt].setLE_TData(ip4Chunk.getLE_TData( 7, 0), 55, 48);
425  this->frmQ[ethChunkCnt].setLE_TKeep(this->frmQ[ethChunkCnt].getLE_TKeep() | (0x40));
426  this->setLen(this->getLen() + 1);
427  }
428  if (ip4Chunk.getLE_TKeep() & 0x02) {
429  this->frmQ[ethChunkCnt].setLE_TData(ip4Chunk.getLE_TData(15, 8), 63, 56);
430  this->frmQ[ethChunkCnt].setLE_TKeep(this->frmQ[ethChunkCnt].getLE_TKeep() | (0x80));
431  this->setLen(this->getLen() + 1);
432  }
433  if ((ip4Chunk.getLE_TLast()) && (ip4Chunk.getLE_TKeep() <= 0x03)) {
434  this->frmQ[ethChunkCnt].setLE_TLast(TLAST);
435  endOfPkt = true;
436  }
437  else {
438  this->frmQ[ethChunkCnt].setLE_TLast(0);
439  }
440  alternate = !alternate;
441  }
442  else {
443  // Build a new chunk and add it to the queue
444  AxisEth newEthChunk(0,0,0);
445  if (ip4Chunk.getLE_TKeep() & 0x04) {
446  newEthChunk.setLE_TData(ip4Chunk.getLE_TData(23, 16), 7, 0);
447  newEthChunk.setLE_TKeep(newEthChunk.getLE_TKeep() | (0x01));
448  }
449  if (ip4Chunk.getLE_TKeep() & 0x08) {
450  newEthChunk.setLE_TData(ip4Chunk.getLE_TData(31, 24), 15, 8);
451  newEthChunk.setLE_TKeep(newEthChunk.getLE_TKeep() | (0x02));
452  }
453  if (ip4Chunk.getLE_TKeep() & 0x10) {
454  newEthChunk.setLE_TData(ip4Chunk.getLE_TData(39, 32), 23,16);
455  newEthChunk.setLE_TKeep(newEthChunk.getLE_TKeep() | (0x04));
456  }
457  if (ip4Chunk.getLE_TKeep() & 0x20) {
458  newEthChunk.setLE_TData(ip4Chunk.getLE_TData(47, 40), 31,24);
459  newEthChunk.setLE_TKeep(newEthChunk.getLE_TKeep() | (0x08));
460  }
461  if (ip4Chunk.getLE_TKeep() & 0x40) {
462  newEthChunk.setLE_TData(ip4Chunk.getLE_TData(55, 48), 39,32);
463  newEthChunk.setLE_TKeep(newEthChunk.getLE_TKeep() | (0x10));
464  }
465  if (ip4Chunk.getLE_TKeep() & 0x80) {
466  newEthChunk.setLE_TData(ip4Chunk.getLE_TData(63, 56), 47,40);
467  newEthChunk.setLE_TKeep(newEthChunk.getLE_TKeep() | (0x20));
468  }
469  // Done with the incoming IP word
470  ip4ChunkCnt++;
471  if (ip4Chunk.getLE_TLast()) {
472  newEthChunk.setLE_TLast(TLAST);
473  this->pushChunk(newEthChunk);
474  endOfPkt = true;
475  }
476  else {
477  newEthChunk.setLE_TLast(0);
478  this->pushChunk(newEthChunk);
479  ethChunkCnt++;
480  // Read and pop a new chunk from the packet
481  ip4Chunk = ipPkt.pullChunk();
482  }
483  alternate = !alternate;
484  }
485  } // End-of while(!endOfPkt)
486  return true;
487  }
SimIp4Packet::pullChunk
AxisIp4 pullChunk()
Definition: SimIp4Packet.hpp:251
Here is the call graph for this function:

◆ getArpPacket()

SimArpPacket SimEthFrame::getArpPacket ( )
inline

Definition at line 234 of file SimEthFrame.hpp.

234  {
235  SimArpPacket arpPacket;
236  LE_tData newTData = 0;
237  LE_tKeep newTKeep = 0;
238  LE_tLast newTLast = 0;
239  int chunkOutCnt = 0;
240  int chunkInpCnt = 1; // Skip 1st chunk with MAC_SA [1:0] and MAC_DA[5:0]
241  bool alternate = true;
242  bool endOfFrm = false;
243  int ethFrmSize = this->size();
244  while (chunkInpCnt < ethFrmSize) {
245  if (endOfFrm) {
246  break;
247  }
248  else if (alternate) {
249  newTData = 0;
250  newTKeep = 0;
251  newTLast = 0;
252  if (this->frmQ[chunkInpCnt].getLE_TKeep() & 0x40) {
253  newTData.range( 7, 0) = this->frmQ[chunkInpCnt].getLE_TData().range(55, 48);
254  newTKeep = newTKeep | (0x01);
255  }
256  if (this->frmQ[chunkInpCnt].getLE_TKeep() & 0x80) {
257  newTData.range(15, 8) = this->frmQ[chunkInpCnt].getLE_TData().range(63, 56);
258  newTKeep = newTKeep | (0x02);
259  }
260  if (this->frmQ[chunkInpCnt].getLE_TLast()) {
261  newTLast = TLAST;
262  endOfFrm = true;
263  arpPacket.pushChunk(AxisArp(newTData, newTKeep, newTLast));
264  }
265  alternate = !alternate;
266  chunkInpCnt++;
267  }
268  else {
269  if (this->frmQ[chunkInpCnt].getLE_TKeep() & 0x01) {
270  newTData.range(23, 16) = this->frmQ[chunkInpCnt].getLE_TData().range( 7, 0);
271  newTKeep = newTKeep | (0x04);
272  }
273  if (this->frmQ[chunkInpCnt].getLE_TKeep() & 0x02) {
274  newTData.range(31, 24) = this->frmQ[chunkInpCnt].getLE_TData().range(15, 8);
275  newTKeep = newTKeep | (0x08);
276  }
277  if (this->frmQ[chunkInpCnt].getLE_TKeep() & 0x04) {
278  newTData.range(39, 32) = this->frmQ[chunkInpCnt].getLE_TData().range(23, 16);
279  newTKeep = newTKeep | (0x10);
280  }
281  if (this->frmQ[chunkInpCnt].getLE_TKeep() & 0x08) {
282  newTData.range(47, 40) = this->frmQ[chunkInpCnt].getLE_TData().range(31, 24);
283  newTKeep = newTKeep | (0x20);
284  }
285  if (this->frmQ[chunkInpCnt].getLE_TKeep() & 0x10) {
286  newTData.range(55, 48) = this->frmQ[chunkInpCnt].getLE_TData().range(39, 32);
287  newTKeep = newTKeep | (0x40);
288  }
289  if (this->frmQ[chunkInpCnt].getLE_TKeep() & 0x20) {
290  newTData.range(63, 56) = this->frmQ[chunkInpCnt].getLE_TData().range(47, 40);
291  newTKeep = newTKeep | (0x80);
292  }
293  if (this->frmQ[chunkInpCnt].getLE_TLast() && (not (this->frmQ[chunkInpCnt].getLE_TKeep() & 0xC0))) {
294  newTLast = TLAST;
295  endOfFrm = true;
296  }
297  alternate = !alternate;
298  chunkOutCnt++;
299  arpPacket.pushChunk(AxisArp(newTData, newTKeep, newTLast));
300  }
301  }
302  return arpPacket;
303  }
SimArpPacket
Class ARP Packet for simulation.
Definition: SimArpPacket.hpp:49
SimArpPacket::pushChunk
void pushChunk(AxisArp arpChunk)
Definition: SimArpPacket.hpp:104
Here is the call graph for this function:
Here is the caller graph for this function:

◆ getIpPacket()

SimIp4Packet SimEthFrame::getIpPacket ( )
inline

Definition at line 162 of file SimEthFrame.hpp.

162  {
163  SimIp4Packet ipPacket;
164  LE_tData newTData = 0;
165  LE_tKeep newTKeep = 0;
166  LE_tLast newTLast = 0;
167  int chunkOutCnt = 0;
168  int chunkInpCnt = 1; // Skip 1st chunk which contains MAC_SA [1:0] | MAC_DA[5:0]
169  bool alternate = true;
170  bool endOfFrm = false;
171  int ethFrmSize = this->size();
172  while (chunkInpCnt < ethFrmSize) {
173  if (endOfFrm) {
174  break;
175  }
176  else if (alternate) {
177  newTData = 0;
178  newTKeep = 0;
179  newTLast = 0;
180  if (this->frmQ[chunkInpCnt].getLE_TKeep() & 0x40) {
181  newTData.range( 7, 0) = this->frmQ[chunkInpCnt].getLE_TData().range(55, 48);
182  newTKeep = newTKeep | (0x01);
183  }
184  if (this->frmQ[chunkInpCnt].getLE_TKeep() & 0x80) {
185  newTData.range(15, 8) = this->frmQ[chunkInpCnt].getLE_TData().range(63, 56);
186  newTKeep = newTKeep | (0x02);
187  }
188  if (this->frmQ[chunkInpCnt].getLE_TLast()) {
189  newTLast = TLAST;
190  endOfFrm = true;
191  ipPacket.pushChunk(AxisIp4(newTData, newTKeep, newTLast));
192  }
193  alternate = !alternate;
194  chunkInpCnt++;
195  }
196  else {
197  if (this->frmQ[chunkInpCnt].getLE_TKeep() & 0x01) {
198  newTData.range(23, 16) = this->frmQ[chunkInpCnt].getLE_TData().range( 7, 0);
199  newTKeep = newTKeep | (0x04);
200  }
201  if (this->frmQ[chunkInpCnt].getLE_TKeep() & 0x02) {
202  newTData.range(31, 24) = this->frmQ[chunkInpCnt].getLE_TData().range(15, 8);
203  newTKeep = newTKeep | (0x08);
204  }
205  if (this->frmQ[chunkInpCnt].getLE_TKeep() & 0x04) {
206  newTData.range(39, 32) = this->frmQ[chunkInpCnt].getLE_TData().range(23, 16);
207  newTKeep = newTKeep | (0x10);
208  }
209  if (this->frmQ[chunkInpCnt].getLE_TKeep() & 0x08) {
210  newTData.range(47, 40) = this->frmQ[chunkInpCnt].getLE_TData().range(31, 24);
211  newTKeep = newTKeep | (0x20);
212  }
213  if (this->frmQ[chunkInpCnt].getLE_TKeep() & 0x10) {
214  newTData.range(55, 48) = this->frmQ[chunkInpCnt].getLE_TData().range(39, 32);
215  newTKeep = newTKeep | (0x40);
216  }
217  if (this->frmQ[chunkInpCnt].getLE_TKeep() & 0x20) {
218  newTData.range(63, 56) = this->frmQ[chunkInpCnt].getLE_TData().range(47, 40);
219  newTKeep = newTKeep | (0x80);
220  }
221  if (this->frmQ[chunkInpCnt].getLE_TLast() && (not (this->frmQ[chunkInpCnt].getLE_TKeep() & 0xC0))) {
222  newTLast = TLAST;
223  endOfFrm = true;
224  }
225  alternate = !alternate;
226  chunkOutCnt++;
227  ipPacket.pushChunk(AxisIp4(newTData, newTKeep, newTLast));
228  }
229  }
230  return ipPacket;
231  }
SimIp4Packet
Class IPv4 Packet for simulation.
Definition: SimIp4Packet.hpp:55
SimIp4Packet::pushChunk
void pushChunk(AxisIp4 ip4Chunk)
Definition: SimIp4Packet.hpp:241
Here is the call graph for this function:
Here is the caller graph for this function:

◆ getLE_MacDestinAddress()

LE_EthAddr SimEthFrame::getLE_MacDestinAddress ( )
inline

Definition at line 136 of file SimEthFrame.hpp.

136 { return frmQ[0].getLE_EthDstAddr(); }

◆ getMacDestinAddress()

EthAddr SimEthFrame::getMacDestinAddress ( )
inline

Definition at line 135 of file SimEthFrame.hpp.

135 { return frmQ[0].getEthDstAddr(); }
Here is the caller graph for this function:

◆ getMacSourceAddress()

EthAddr SimEthFrame::getMacSourceAddress ( )
inline

Definition at line 141 of file SimEthFrame.hpp.

141  { EthAddr macHi = ((EthAddr)(frmQ[0].getEthSrcAddrHi()) << 32);
142  EthAddr macLo = ((EthAddr)(frmQ[1].getEthSrcAddrLo()) << 0);
143  return (macHi | macLo); }
EthAddr
ap_uint< 48 > EthAddr
Definition: AxisEth.hpp:120
Here is the caller graph for this function:

◆ getTypeLength()

EthTypeLen SimEthFrame::getTypeLength ( )
inline

Definition at line 147 of file SimEthFrame.hpp.

147 { return frmQ[1].getEthTypelen(); }
Here is the caller graph for this function:

◆ length()

int SimEthFrame::length ( )
inline

Definition at line 127 of file SimEthFrame.hpp.

127 { return this->len; }
Here is the caller graph for this function:

◆ pullChunk()

AxisEth SimEthFrame::pullChunk ( )
inline

Definition at line 119 of file SimEthFrame.hpp.

119  {
120  AxisEth headingChunk = this->front();
121  this->pop_front();
122  setLen(getLen() - headingChunk.getLen());
123  return headingChunk;
124  }
AxisRaw::getLen
int getLen() const
Definition: AxisRaw.hpp:411
Here is the call graph for this function:

◆ pushChunk()

void SimEthFrame::pushChunk ( AxisEth  ethChunk)
inline

Definition at line 109 of file SimEthFrame.hpp.

109  {
110  if (this->size() > 0) {
111  // Always clear 'TLAST' bit of previous chunck
112  this->frmQ[this->size()-1].setLE_TLast(0);
113  }
114  this->push_back(ethChunk);
115  this->setLen(this->getLen() + ethChunk.getLen());
116  }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ setMacDestinAddress()

void SimEthFrame::setMacDestinAddress ( EthAddr  addr)
inline

Definition at line 133 of file SimEthFrame.hpp.

133 { frmQ[0].setEthDstAddr(addr); }
Here is the caller graph for this function:

◆ setMacSourceAddress()

void SimEthFrame::setMacSourceAddress ( EthAddr  addr)
inline

Definition at line 138 of file SimEthFrame.hpp.

138  { frmQ[0].setEthSrcAddrHi(addr);
139  frmQ[1].setEthSrcAddrLo(addr); }
Here is the caller graph for this function:

◆ setTypeLength()

void SimEthFrame::setTypeLength ( EthTypeLen  typLen)
inline

Definition at line 145 of file SimEthFrame.hpp.

145 { frmQ[1].setEthTypeLen(typLen); }
Here is the caller graph for this function:

◆ size()

int SimEthFrame::size ( )
inline

Definition at line 130 of file SimEthFrame.hpp.

130 { return this->frmQ.size(); }
Here is the caller graph for this function:

◆ sizeOfPayload()

int SimEthFrame::sizeOfPayload ( )
inline

Definition at line 150 of file SimEthFrame.hpp.

150  {
151  int ethTypLen = this->getTypeLength();
152  if (ethTypLen < 0x0600) { // .i.e 1536
153  return ethTypLen;
154  }
155  else {
156  // Retrieve the payload length from the deque
157  return (this->length());
158  }
159  }
SimEthFrame::getTypeLength
EthTypeLen getTypeLength()
Definition: SimEthFrame.hpp:147
Here is the call graph for this function:
Here is the caller graph for this function:

◆ writeToDatFile()

bool SimEthFrame::writeToDatFile ( ofstream &  outFileStream)
inline

Dump this Ethernet frame as raw AxisEth chunks into a file.

Parameters
[in]outFileStreamA reference to the file stream to write.
Returns
true upon success, otherwise false.

Definition at line 495 of file SimEthFrame.hpp.

495  {
496  for (int i=0; i < this->size(); i++) {
497  AxisEth axisEth = this->frmQ[i];
498  if (not writeAxisRawToFile(axisEth, outFileStream)) {
499  return false;
500  }
501  }
502  return true;
503  }
writeAxisRawToFile
bool writeAxisRawToFile(AxisRaw &axisRaw, ofstream &outFileStream)
Dump an Axis raw data chunk to a file.
Definition: SimNtsUtils.cpp:416
Here is the call graph for this function:
Here is the caller graph for this function:
The documentation for this class was generated from the following file: