{

using namespace std::placeholders;

phy_capture = capture;

lwipHandler = lwipCallback.add(std::bind(&Netdump::netdumpCapture, this, _1, _2, _3, _4, _5));

{

netDumpFilter = nf;

netDumpCallback = nc;

{

out.printf("netDump starting\r\n");

setCallback([&out, ndd, this](const Packet & ndp)

{

printDumpProcess(out, ndd, ndp);

}, nf);

{

writePcapHeader(outfile);

setCallback([&outfile, this](const Packet & ndp)

{

fileDumpProcess(outfile, ndp);

}, nf);

{

if (!packetBuffer)

{

packetBuffer = new (std::nothrow) char[tcpBufferSize];

if (!packetBuffer)

{

return false;

}

}

bufferIndex = 0;

schedule_function([&tcpDumpServer, this, nf]()

{

tcpDumpLoop(tcpDumpServer, nf);

});

return true;

{

if (lwipCallback.execute(netif_idx, data, len, out, success) == 0)

{

phy_capture = nullptr; // No active callback/netdump instances, will be set again by new object.

}

{

if (netDumpCallback)

{

Packet np(millis(), netif_idx, data, len, out, success);

if (netDumpFilter && !netDumpFilter(np))

{

return;

}

netDumpCallback(np);

}

{

uint32_t pcapHeader[6];

pcapHeader[0] = 0xa1b2c3d4; // pcap magic number

pcapHeader[1] = 0x00040002; // pcap major/minor version

pcapHeader[2] = 0; // pcap UTC correction in seconds

pcapHeader[3] = 0; // pcap time stamp accuracy

pcapHeader[4] = maxPcapLength; // pcap max packet length per record

pcapHeader[5] = 1; // pacp data linkt type = ethernet

s.write(reinterpret_cast<char*>(pcapHeader), 24);

{

size_t incl_len = np.getPacketSize() > maxPcapLength ? maxPcapLength : np.getPacketSize();

uint32_t pcapHeader[4];

struct timeval tv;

gettimeofday(&tv, nullptr);

pcapHeader[0] = tv.tv_sec;

pcapHeader[1] = tv.tv_usec;

pcapHeader[2] = incl_len;

pcapHeader[3] = np.getPacketSize();

outfile.write(reinterpret_cast<char*>(pcapHeader), 16); // pcap record header

outfile.write(np.rawData(), incl_len);

{

if (np.isTCP() && np.hasPort(tcpDumpClient.localPort()))

{

// skip myself

return;

}

size_t incl_len = np.getPacketSize() > maxPcapLength ? maxPcapLength : np.getPacketSize();

if (bufferIndex + 16 + incl_len < tcpBufferSize) // only add if enough space available

{

struct timeval tv;

gettimeofday(&tv, nullptr);

uint32_t* pcapHeader = reinterpret_cast<uint32_t*>(&packetBuffer[bufferIndex]);

pcapHeader[0] = tv.tv_sec; // add pcap record header

pcapHeader[1] = tv.tv_usec;

pcapHeader[2] = incl_len;

pcapHeader[3] = np.getPacketSize();

bufferIndex += 16; // pcap header size

memcpy(&packetBuffer[bufferIndex], np.rawData(), incl_len);

bufferIndex += incl_len;

}

if (bufferIndex && tcpDumpClient && tcpDumpClient.availableForWrite() >= (int)bufferIndex)

{

tcpDumpClient.write(packetBuffer, bufferIndex);

bufferIndex = 0;

}

{

if (tcpDumpServer.hasClient())

{

tcpDumpClient = tcpDumpServer.available();

tcpDumpClient.setNoDelay(true);

bufferIndex = 0;

writePcapHeader(tcpDumpClient);

setCallback([this](const Packet & ndp)

{

tcpDumpProcess(ndp);

}, nf);

}

if (!tcpDumpClient || !tcpDumpClient.connected())

{

setCallback(nullptr);

}

if (bufferIndex && tcpDumpClient && tcpDumpClient.availableForWrite() >= (int)bufferIndex)

{

tcpDumpClient.write(packetBuffer, bufferIndex);

bufferIndex = 0;

}

if (tcpDumpServer.status() != CLOSED)

{

schedule_function([&tcpDumpServer, this, nf]()

{

tcpDumpLoop(tcpDumpServer, nf);

});

}