BodgeMaster
/
NORM-mirror
mirror of https://github.com/USNavalResearchLaboratory/norm.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[WIP] Cmake (#8) 

* Adds initial cmake

* Renames include according common convention

* Tries to include examples

* Changes to protokit

* Improves install step

* Removes /protokit

* Fixes some comments

* Adds a few feature tests

* Adds FLOCK includes

* Removes if in feature tests

* Fixes missing normApi.cpp

* Adds missing include

* Fixes bad rename
pull/9/head
mjvk 2020-05-18 16:19:04 +02:00 committed by GitHub
parent a55f796084
commit 8d8c3f0da5
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
11 changed files with 2406 additions and 2177 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

164
CMakeLists.txt Normal file
View File

@ -0,0 +1,164 @@
cmake_minimum_required(VERSION 3.11)
# set the project name
project(norm VERSION 1.5.8)
set(COMMON src/common)
option(NORM_BUILD_EXAMPLES "Enables building of the examples in /examples." OFF)
include(CheckCXXSymbolExists)
check_cxx_symbol_exists(dirfd "dirent.h" HAVE_DIRFD)
if(HAVE_DIRFD)
list(APPEND PLATFORM_DEFINITIONS HAVE_DIRFD)
endif()
check_cxx_symbol_exists(lockf "unistd.h" HAVE_LOCKF)
if(HAVE_LOCKF)
list(APPEND PLATFORM_DEFINITIONS HAVE_LOCKF)
endif()
check_cxx_symbol_exists(flock "sys/file.h" HAVE_FLOCK)
if(HAVE_FLOCK)
list(APPEND PLATFORM_DEFINITIONS HAVE_FLOCK)
endif()
# Check for libraries
find_package(protokit QUIET)
if(NOT protokit_FOUND)
include(FetchContent)
FetchContent_Declare(
protokit
GIT_REPOSITORY https://github.com/USNavalResearchLaboratory/protolib.git
GIT_TAG origin/master
)
FetchContent_MakeAvailable(protokit)
endif()
# List header files
list(APPEND PUBLIC_HEADER_FILES
include/galois.h
include/normApi.h
include/normEncoder.h
include/normEncoderMDP.h
include/normEncoderRS16.h
include/normEncoderRS8.h
include/normFile.h
include/normMessage.h
include/normNode.h
include/normObject.h
include/normPostProcess.h
include/normSegment.h
include/normSession.h
include/normSimAgent.h
include/normVersion.h
)
# List platform-independent source files
list(APPEND COMMON_SOURCE_FILES
${COMMON}/galois.cpp
${COMMON}/normApi.cpp
${COMMON}/normEncoder.cpp
${COMMON}/normEncoderMDP.cpp
${COMMON}/normEncoderRS16.cpp
${COMMON}/normEncoderRS8.cpp
${COMMON}/normFile.cpp
${COMMON}/normMessage.cpp
${COMMON}/normNode.cpp
${COMMON}/normObject.cpp
${COMMON}/normSegment.cpp
${COMMON}/normSession.cpp )
# Setup platform independent include directory
list(APPEND INCLUDE_DIRS ${CMAKE_CURRENT_LIST_DIR}/include )
# Setup platform dependent libraries, defines, source file and compiler flags
if(MSVC)
list(APPEND PLATFORM_LIBS Shell32)
list(APPEND PLATFORM_DEFINITIONS _CONSOLE)
list(APPEND PLATFORM_SOURCE_FILES src/win32/win32PostProcess.cpp)
elseif(UNIX)
list(APPEND PLATFORM_SOURCE_FILES src/unix/unixPostProcess.cpp)
endif()
include(GNUInstallDirs)
# Setup target
add_library(norm ${PLATFORM_SOURCE_FILES} ${COMMON_SOURCE_FILES} ${PUBLIC_HEADER_FILES})
target_link_libraries(norm PRIVATE ${PLATFORM_LIBS} protokit::protokit)
target_compile_definitions(norm PUBLIC ${PLATFORM_DEFINITIONS})
target_compile_options(norm PUBLIC ${PLATFORM_FLAGS})
target_include_directories(norm PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
target_include_directories(norm PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include> $<INSTALL_INTERFACE:include>)
# Install target
install( TARGETS norm EXPORT normTargets
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} )
set(INSTALL_CONFIGDIR ${CMAKE_INSTALL_LIBDIR}/cmake/norm)
install( EXPORT normTargets
FILE normTargets.cmake
NAMESPACE norm::
DESTINATION ${INSTALL_CONFIGDIR}
)
install(DIRECTORY include/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/norm)
# Create a ConfigVersion.cmake file
include(CMakePackageConfigHelpers)
write_basic_package_version_file(
${CMAKE_CURRENT_BINARY_DIR}/normConfigVersion.cmake
VERSION ${PROJECT_VERSION}
COMPATIBILITY AnyNewerVersion
)
configure_package_config_file(${CMAKE_CURRENT_LIST_DIR}/cmake/normConfig.cmake.in
${CMAKE_CURRENT_BINARY_DIR}/normConfig.cmake
INSTALL_DESTINATION ${INSTALL_CONFIGDIR}
)
# Install the config, configversion and custom find modules
install(FILES
${CMAKE_CURRENT_BINARY_DIR}/normConfig.cmake
${CMAKE_CURRENT_BINARY_DIR}/normConfigVersion.cmake
DESTINATION ${INSTALL_CONFIGDIR}
)
##############################################
# Exporting from the build tree
export(EXPORT normTargets
FILE ${CMAKE_CURRENT_BINARY_DIR}/normTargets.cmake
NAMESPACE norm::)
# Register package in user's package registry
export(PACKAGE norm)
if(NORM_BUILD_EXAMPLES)
# Setup examples
list(APPEND examples
#normDataExample
normDataRecv
normDataSend
normFileRecv
normFileSend
normStreamRecv
normStreamSend
normMsgr
normStreamer
normCast
normClient
normServer
#wintest
)
foreach(example ${examples})
add_executable(${example} examples/${example}.cpp examples/normSocket.cpp)
target_link_libraries(${example} PRIVATE norm protokit::protokit)
endforeach()
endif()

10
cmake/normConfig.cmake.in Normal file
View File

@ -0,0 +1,10 @@
include(GNUInstallDirs)
include(CMakeFindDependencyMacro)
# Same syntax as find_package
find_dependency(protokit REQUIRED)
# Add the targets file
include("${CMAKE_CURRENT_LIST_DIR}/normTargets.cmake")

1
examples/normCast.cpp
View File

@ -2,6 +2,7 @@
#include "normApi.h" #include "normApi.h"
#include <stdio.h> // for printf(), etc #include <stdio.h> // for printf(), etc
#include <stdlib.h> // for atoi(), etc #include <stdlib.h> // for atoi(), etc
#include <cassert>
#ifdef WIN32 #ifdef WIN32
#include <windows.h> #include <windows.h>

2
examples/normFileRecv.cpp
View File

@ -63,7 +63,7 @@ int main(int argc, char* argv[])
// NOTE: These are debugging routines available // NOTE: These are debugging routines available
// (not necessary for normal app use) // (not necessary for normal app use)
// (Need to include "protolib/common/protoDebug.h" for this // (Need to include "common/protoDebug.h" for this
//SetDebugLevel(2); //SetDebugLevel(2);
// Uncomment to turn on debug NORM message tracing // Uncomment to turn on debug NORM message tracing
//NormSetMessageTrace(session, true); //NormSetMessageTrace(session, true);

2
examples/normFileSend.cpp
View File

@ -71,7 +71,7 @@ int main(int argc, char* argv[])
// NOTE: These are some debugging routines available // NOTE: These are some debugging routines available
// (not necessary for normal app use) // (not necessary for normal app use)
// (Need to include "protolib/common/protoDebug.h" for this // (Need to include "common/protoDebug.h" for this
//SetDebugLevel(2); //SetDebugLevel(2);
// Uncomment to turn on debug NORM message tracing // Uncomment to turn on debug NORM message tracing
NormSetMessageTrace(session, true); NormSetMessageTrace(session, true);

2
examples/normStreamRecv.cpp
View File

@ -48,7 +48,7 @@ int main(int argc, char* argv[])
// NOTE: These are debugging routines available // NOTE: These are debugging routines available
// (not necessary for normal app use) // (not necessary for normal app use)
// (Need to include "protolib/common/protoDebug.h" for this // (Need to include "common/protoDebug.h" for this
NormSetDebugLevel(3); NormSetDebugLevel(3);
// Uncomment to turn on debug NORM message tracing // Uncomment to turn on debug NORM message tracing
NormSetMessageTrace(session, true); NormSetMessageTrace(session, true);

4
examples/wintest.cpp
View File

@ -39,7 +39,7 @@ int main(int argc, char** argv)
Win32InputHandler inputHandler; Win32InputHandler inputHandler;
inputHandler.Start(); inputHandler.Open();
while (true) while (true)
{ {
@ -51,7 +51,7 @@ int main(int argc, char** argv)
DWORD dwWritten; DWORD dwWritten;
BOOL fSuccess = WriteFile(hStdout, buffer, numBytes, &dwWritten, NULL); BOOL fSuccess = WriteFile(hStdout, buffer, numBytes, &dwWritten, NULL);
} }
inputHandler.Stop(); inputHandler.Close();
return 0; return 0;
} // end main() } // end main()

6
src/common/normFile.cpp
View File

@ -17,6 +17,12 @@ static inline int dirfd(DIR *dir) {return (dir->dd_fd);}
#endif // HAVE_DIRFD #endif // HAVE_DIRFD
#endif // if/else WIN32 #endif // if/else WIN32
#ifdef HAVE_FLOCK
#include <sys/file.h>
#elif defined(HAVE_LOCKF)
#include <unistd.h>
#endif
#ifndef _WIN32_WCE #ifndef _WIN32_WCE
#include <fcntl.h> #include <fcntl.h>
#include <sys/types.h> #include <sys/types.h>

3841
src/common/normSession.cpp
View File

File diff suppressed because it is too large Load Diff

549
src/common/pcap2norm.cpp
View File

@ -2,7 +2,6 @@
// Assumes UDP packets in tcpdump trace file (pcap file) are // Assumes UDP packets in tcpdump trace file (pcap file) are
// MGEN packets and parses to build an MGEN log file // MGEN packets and parses to build an MGEN log file
#include <stdio.h> #include <stdio.h>
#include <pcap.h> #include <pcap.h>
#include <sys/socket.h> // for PF_ types (protocol family) #include <sys/socket.h> // for PF_ types (protocol family)
@ -12,92 +11,95 @@
#include "normSession.h" #include "normSession.h"
void NormTrace2(const struct timeval& currentTime, void NormTrace2(const struct timeval &currentTime,
const NormMsg& msg, const NormMsg &msg,
const ProtoAddress& srcAddr, const ProtoAddress &srcAddr,
const ProtoAddress& dstAddr); const ProtoAddress &dstAddr);
void Usage() void Usage()
{ {
fprintf(stderr, "pcap2norm [pcapInputFile [outputFile]]\n"); fprintf(stderr, "pcap2norm [pcapInputFile [outputFile]]\n");
} }
int main(int argc, char* argv[]) int main(int argc, char *argv[])
{ {
// Use stdin/stdout by default // Use stdin/stdout by default
FILE* infile = stdin; FILE *infile = stdin;
FILE* outfile = stdout; FILE *outfile = stdout;
switch(argc) switch (argc)
{ {
case 1: case 1:
// using default stdin/stdout // using default stdin/stdout
break; break;
case 2: case 2:
// using named input pcap file and stdout // using named input pcap file and stdout
if (NULL == (infile = fopen(argv[1], "r"))) if (NULL == (infile = fopen(argv[1], "r")))
{ {
perror("pcap2norm: error opening input file"); perror("pcap2norm: error opening input file");
return -1;
}
break;
case 3:
// use name input and output files
if (NULL == (infile = fopen(argv[1], "r")))
{
perror("pcap2norm: error opening input file");
return -1;
}
if (NULL == (outfile = fopen(argv[2], "w+")))
{
perror("pcap2norm: error opening output file");
return -1;
}
break;
default:
fprintf(stderr, "pcap2norm: error: too many arguments!\n");
Usage();
return -1; return -1;
} // end switch(argc) }
break;
char pcapErrBuf[PCAP_ERRBUF_SIZE+1]; case 3:
// use name input and output files
if (NULL == (infile = fopen(argv[1], "r")))
{
perror("pcap2norm: error opening input file");
return -1;
}
if (NULL == (outfile = fopen(argv[2], "w+")))
{
perror("pcap2norm: error opening output file");
return -1;
}
break;
default:
fprintf(stderr, "pcap2norm: error: too many arguments!\n");
Usage();
return -1;
} // end switch(argc)
char pcapErrBuf[PCAP_ERRBUF_SIZE + 1];
pcapErrBuf[PCAP_ERRBUF_SIZE] = '\0'; pcapErrBuf[PCAP_ERRBUF_SIZE] = '\0';
pcap_t* pcapDevice = pcap_fopen_offline(infile, pcapErrBuf); pcap_t *pcapDevice = pcap_fopen_offline(infile, pcapErrBuf);
if (NULL == pcapDevice) if (NULL == pcapDevice)
{ {
fprintf(stderr, "pcap2norm: pcap_fopen_offline() error: %s\n", pcapErrBuf); fprintf(stderr, "pcap2norm: pcap_fopen_offline() error: %s\n", pcapErrBuf);
if (stdin != infile) fclose(infile); if (stdin != infile)
if (stdout != outfile) fclose(outfile); fclose(infile);
if (stdout != outfile)
fclose(outfile);
return -1; return -1;
} }
int deviceType = pcap_datalink(pcapDevice); int deviceType = pcap_datalink(pcapDevice);
UINT32 alignedBuffer[4096/4]; // 4096 byte buffer for packet parsing UINT32 alignedBuffer[4096 / 4]; // 4096 byte buffer for packet parsing
UINT16* ethBuffer = ((UINT16*)alignedBuffer) + 1; UINT16 *ethBuffer = ((UINT16 *)alignedBuffer) + 1;
unsigned int maxBytes = 4096 - 2; // due to offset, can only use 4094 bytes of buffer unsigned int maxBytes = 4096 - 2; // due to offset, can only use 4094 bytes of buffer
pcap_pkthdr hdr; pcap_pkthdr hdr;
const u_char* pktData; const u_char *pktData;
while(NULL != (pktData = pcap_next(pcapDevice, &hdr))) while (NULL != (pktData = pcap_next(pcapDevice, &hdr)))
{ {
unsigned int numBytes = maxBytes; unsigned int numBytes = maxBytes;
if (hdr.caplen < numBytes) numBytes = hdr.caplen; if (hdr.caplen < numBytes)
numBytes = hdr.caplen;
ProtoPktETH::Type ethType; ProtoPktETH::Type ethType;
unsigned int payloadLength; unsigned int payloadLength;
UINT32* payloadPtr; UINT32 *payloadPtr;
if (DLT_NULL == deviceType) if (DLT_NULL == deviceType)
{ {
// pcap was captured from "loopback" device // pcap was captured from "loopback" device
memcpy(alignedBuffer, pktData, numBytes); memcpy(alignedBuffer, pktData, numBytes);
switch (alignedBuffer[0]) switch (alignedBuffer[0])
{ {
case PF_INET: case PF_INET:
ethType = ProtoPktETH::IP; ethType = ProtoPktETH::IP;
break; break;
case PF_INET6: case PF_INET6:
ethType = ProtoPktETH::IPv6; ethType = ProtoPktETH::IPv6;
break; break;
default: default:
continue; // not an IP packet continue; // not an IP packet
} }
payloadLength = numBytes - 4; payloadLength = numBytes - 4;
payloadPtr = alignedBuffer + 1; payloadPtr = alignedBuffer + 1;
@ -110,14 +112,14 @@ int main(int argc, char* argv[])
{ {
fprintf(stderr, "pcap2norm error: invalid Ether frame in pcap file\n"); fprintf(stderr, "pcap2norm error: invalid Ether frame in pcap file\n");
continue; continue;
} }
ethType = ethPkt.GetType(); ethType = ethPkt.GetType();
payloadLength = ethPkt.GetPayloadLength(); payloadLength = ethPkt.GetPayloadLength();
// This is done know we offset the ethBuffer above // This is done know we offset the ethBuffer above
payloadPtr = alignedBuffer + (2 + ethPkt.GetLength() - ethPkt.GetPayloadLength())/4; payloadPtr = alignedBuffer + (2 + ethPkt.GetLength() - ethPkt.GetPayloadLength()) / 4;
//payloadPtr = (UINT32*)ethPkt.AccessPayload(); //payloadPtr = (UINT32*)ethPkt.AccessPayload();
} }
ProtoPktIP ipPkt; ProtoPktIP ipPkt;
ProtoAddress srcAddr, dstAddr; ProtoAddress srcAddr, dstAddr;
if ((ProtoPktETH::IP == ethType) || if ((ProtoPktETH::IP == ethType) ||
@ -130,25 +132,25 @@ int main(int argc, char* argv[])
} }
switch (ipPkt.GetVersion()) switch (ipPkt.GetVersion())
{ {
case 4: case 4:
{ {
ProtoPktIPv4 ip4Pkt(ipPkt); ProtoPktIPv4 ip4Pkt(ipPkt);
ip4Pkt.GetDstAddr(dstAddr); ip4Pkt.GetDstAddr(dstAddr);
ip4Pkt.GetSrcAddr(srcAddr); ip4Pkt.GetSrcAddr(srcAddr);
break; break;
} }
case 6: case 6:
{ {
ProtoPktIPv6 ip6Pkt(ipPkt); ProtoPktIPv6 ip6Pkt(ipPkt);
ip6Pkt.GetDstAddr(dstAddr); ip6Pkt.GetDstAddr(dstAddr);
ip6Pkt.GetSrcAddr(srcAddr); ip6Pkt.GetSrcAddr(srcAddr);
break; break;
} }
default: default:
{ {
PLOG(PL_ERROR,"pcap2norm Error: Invalid IP pkt version.\n"); PLOG(PL_ERROR, "pcap2norm Error: Invalid IP pkt version.\n");
break; break;
} }
} }
//PLOG(PL_ALWAYS, "pcap2norm IP packet dst>%s ", dstAddr.GetHostString()); //PLOG(PL_ALWAYS, "pcap2norm IP packet dst>%s ", dstAddr.GetHostString());
//PLOG(PL_ALWAYS," src>%s length>%d\n", srcAddr.GetHostString(), ipPkt.GetLength()); //PLOG(PL_ALWAYS," src>%s length>%d\n", srcAddr.GetHostString(), ipPkt.GetLength());
@ -157,13 +159,15 @@ int main(int argc, char* argv[])
{ {
fprintf(stderr, "eth type = %d\n", ethType); fprintf(stderr, "eth type = %d\n", ethType);
} }
if (!srcAddr.IsValid()) continue; // wasn't an IP packet if (!srcAddr.IsValid())
continue; // wasn't an IP packet
ProtoPktUDP udpPkt; ProtoPktUDP udpPkt;
if (!udpPkt.InitFromPacket(ipPkt)) continue; // not a UDP packet if (!udpPkt.InitFromPacket(ipPkt))
continue; // not a UDP packet
NormMsg msg; NormMsg msg;
if (msg.CopyFromBuffer((const char*)udpPkt.GetPayload(), udpPkt.GetPayloadLength())) if (msg.CopyFromBuffer((const char *)udpPkt.GetPayload(), udpPkt.GetPayloadLength()))
{ {
srcAddr.SetPort(udpPkt.GetSrcPort()); srcAddr.SetPort(udpPkt.GetSrcPort());
msg.AccessAddress() = srcAddr; msg.AccessAddress() = srcAddr;
@ -173,51 +177,47 @@ int main(int argc, char* argv[])
else else
{ {
fprintf(stderr, "pcap2norm warning: UDP packet not an MGEN packet?\n"); fprintf(stderr, "pcap2norm warning: UDP packet not an MGEN packet?\n");
} }
} // end while (pcap_next()) } // end while (pcap_next())
} // end main()
} // end main()
static UINT8 lastFecId = 0; static UINT8 lastFecId = 0;
void NormTrace2(const struct timeval& currentTime, void NormTrace2(const struct timeval &currentTime,
const NormMsg& msg, const NormMsg &msg,
const ProtoAddress& srcAddr, const ProtoAddress &srcAddr,
const ProtoAddress& dstAddr) const ProtoAddress &dstAddr)
{ {
UINT8 fecM = 8; // NOTE - this assumes 16-bit RS code for fec_id == 2 UINT8 fecM = 8; // NOTE - this assumes 16-bit RS code for fec_id == 2
static const char* MSG_NAME[] = static const char *MSG_NAME[] =
{ {
"INVALID", "INVALID",
"INFO", "INFO",
"DATA", "DATA",
"CMD", "CMD",
"NACK", "NACK",
"ACK", "ACK",
"REPORT" "REPORT"};
}; static const char *CMD_NAME[] =
static const char* CMD_NAME[] = {
{ "CMD(INVALID)",
"CMD(INVALID)", "CMD(FLUSH)",
"CMD(FLUSH)", "CMD(EOT)",
"CMD(EOT)", "CMD(SQUELCH)",
"CMD(SQUELCH)", "CMD(CC)",
"CMD(CC)", "CMD(REPAIR_ADV)",
"CMD(REPAIR_ADV)", "CMD(ACK_REQ)",
"CMD(ACK_REQ)", "CMD(APP)"};
"CMD(APP)" static const char *REQ_NAME[] =
}; {
static const char* REQ_NAME[] = "INVALID",
{ "WATERMARK",
"INVALID", "RTT",
"WATERMARK", "APP"};
"RTT",
"APP"
};
NormMsg::Type msgType = msg.GetType(); NormMsg::Type msgType = msg.GetType();
UINT16 length = msg.GetLength(); UINT16 length = msg.GetLength();
UINT16 seq = msg.GetSequence(); UINT16 seq = msg.GetSequence();
@ -225,56 +225,53 @@ void NormTrace2(const struct timeval& currentTime,
src[63] = dst[63] = '\0'; src[63] = dst[63] = '\0';
srcAddr.GetHostString(src, 63); srcAddr.GetHostString(src, 63);
dstAddr.GetHostString(dst, 63); dstAddr.GetHostString(dst, 63);
#ifdef _WIN32_WCE #ifdef _WIN32_WCE
struct tm timeStruct; struct tm timeStruct;
timeStruct.tm_hour = currentTime.tv_sec / 3600; timeStruct.tm_hour = currentTime.tv_sec / 3600;
unsigned long hourSecs = 3600 * timeStruct.tm_hour; unsigned long hourSecs = 3600 * timeStruct.tm_hour;
timeStruct.tm_min = (currentTime.tv_sec - (hourSecs)) / 60; timeStruct.tm_min = (currentTime.tv_sec - (hourSecs)) / 60;
timeStruct.tm_sec = currentTime.tv_sec - (hourSecs) - (60*timeStruct.tm_min); timeStruct.tm_sec = currentTime.tv_sec - (hourSecs) - (60 * timeStruct.tm_min);
timeStruct.tm_hour = timeStruct.tm_hour % 24; timeStruct.tm_hour = timeStruct.tm_hour % 24;
struct tm* ct = &timeStruct; struct tm *ct = &timeStruct;
#else #else
time_t secs = (time_t)currentTime.tv_sec; time_t secs = (time_t)currentTime.tv_sec;
struct tm* ct = gmtime(&secs); struct tm *ct = gmtime(&secs);
#endif // if/else _WIN32_WCE #endif // if/else _WIN32_WCE
PLOG(PL_ALWAYS, "trace>%02d:%02d:%02d.%06lu ", PLOG(PL_ALWAYS, "trace>%02d:%02d:%02d.%06lu ",
(int)ct->tm_hour, (int)ct->tm_min, (int)ct->tm_sec, (unsigned int)currentTime.tv_usec); (int)ct->tm_hour, (int)ct->tm_min, (int)ct->tm_sec, (unsigned int)currentTime.tv_usec);
PLOG(PL_ALWAYS, "src>%s/%hu dst>%s/%hu id>0x%08x ", src, srcAddr.GetPort(), dst, dstAddr.GetPort(), (UINT32)msg.GetSourceId()); PLOG(PL_ALWAYS, "src>%s/%hu dst>%s/%hu id>0x%08x ", src, srcAddr.GetPort(), dst, dstAddr.GetPort(), (UINT32)msg.GetSourceId());
bool clrFlag = false; bool clrFlag = false;
switch (msgType) switch (msgType)
{ {
case NormMsg::INFO: case NormMsg::INFO:
{
const NormInfoMsg &info = (const NormInfoMsg &)msg;
lastFecId = info.GetFecId();
PLOG(PL_ALWAYS, "inst>%hu seq>%hu INFO obj>%hu ",
info.GetInstanceId(), seq, (UINT16)info.GetObjectId());
break;
}
case NormMsg::DATA:
{
const NormDataMsg &data = (const NormDataMsg &)msg;
lastFecId = data.GetFecId();
PLOG(PL_ALWAYS, "inst>%hu seq>%hu DATA obj>%hu blk>%u seg>%04hu ",
data.GetInstanceId(),
seq,
//data.IsData() ? "DATA" : "PRTY",
(UINT16)data.GetObjectId(),
(UINT32)data.GetFecBlockId(fecM).GetValue(),
(UINT16)data.GetFecSymbolId(fecM));
if (data.IsStream())
{ {
const NormInfoMsg& info = (const NormInfoMsg&)msg; UINT32 offset = NormDataMsg::ReadStreamPayloadOffset(data.GetPayload());
lastFecId = info.GetFecId(); PLOG(PL_ALWAYS, "offset>%lu ", offset);
PLOG(PL_ALWAYS, "inst>%hu seq>%hu INFO obj>%hu ",
info.GetInstanceId(), seq, (UINT16)info.GetObjectId());
break;
} }
case NormMsg::DATA: /*
{
const NormDataMsg& data = (const NormDataMsg&)msg;
lastFecId = data.GetFecId();
PLOG(PL_ALWAYS, "inst>%hu seq>%hu DATA obj>%hu blk>%u seg>%04hu ",
data.GetInstanceId(),
seq,
//data.IsData() ? "DATA" : "PRTY",
(UINT16)data.GetObjectId(),
(UINT32)data.GetFecBlockId(fecM).GetValue(),
(UINT16)data.GetFecSymbolId(fecM));
if (data.IsStream())
{
UINT32 offset = NormDataMsg::ReadStreamPayloadOffset(data.GetPayload());
PLOG(PL_ALWAYS, "offset>%lu ", offset);
}
/*
if (data.IsData() && data.IsStream()) if (data.IsData() && data.IsStream())
{ {
//if (NormDataMsg::StreamPayloadFlagIsSet(data.GetPayload(), NormDataMsg::FLAG_MSG_START)) //if (NormDataMsg::StreamPayloadFlagIsSet(data.GetPayload(), NormDataMsg::FLAG_MSG_START))
@ -288,124 +285,124 @@ void NormTrace2(const struct timeval& currentTime,
PLOG(PL_ALWAYS, "(stream end) "); PLOG(PL_ALWAYS, "(stream end) ");
} }
*/ */
break; break;
} }
case NormMsg::CMD: case NormMsg::CMD:
{
const NormCmdMsg &cmd = static_cast<const NormCmdMsg &>(msg);
NormCmdMsg::Flavor flavor = cmd.GetFlavor();
PLOG(PL_ALWAYS, "inst>%hu seq>%hu %s ", cmd.GetInstanceId(), seq, CMD_NAME[flavor]);
switch (flavor)
{ {
const NormCmdMsg& cmd = static_cast<const NormCmdMsg&>(msg); case NormCmdMsg::ACK_REQ:
NormCmdMsg::Flavor flavor = cmd.GetFlavor();
PLOG(PL_ALWAYS, "inst>%hu seq>%hu %s ", cmd.GetInstanceId(), seq, CMD_NAME[flavor]);
switch (flavor)
{
case NormCmdMsg::ACK_REQ:
{
int index = ((const NormCmdAckReqMsg&)msg).GetAckType();
index = MIN(index, 3);
PLOG(PL_ALWAYS, "(%s) ", REQ_NAME[index]);
break;
}
case NormCmdMsg::SQUELCH:
{
const NormCmdSquelchMsg& squelch =
static_cast<const NormCmdSquelchMsg&>(msg);
PLOG(PL_ALWAYS, " obj>%hu blk>%lu seg>%hu ",
(UINT16)squelch.GetObjectId(),
(UINT32)squelch.GetFecBlockId(fecM).GetValue(),
(UINT16)squelch.GetFecSymbolId(fecM));
break;
}
case NormCmdMsg::FLUSH:
{
const NormCmdFlushMsg& flush =
static_cast<const NormCmdFlushMsg&>(msg);
PLOG(PL_ALWAYS, " obj>%hu blk>%lu seg>%hu ",
(UINT16)flush.GetObjectId(),
(UINT32)flush.GetFecBlockId(fecM).GetValue(),
(UINT16)flush.GetFecSymbolId(fecM));
// Print acking node list (if any)
UINT16 nodeCount = flush.GetAckingNodeCount();
if (nodeCount > 0)
{
PLOG(PL_ALWAYS, "ackers>");
for (UINT16 i = 0; i < nodeCount; i++)
{
if (i > 0) PLOG(PL_ALWAYS, ",");
PLOG(PL_ALWAYS,"0x%08x", (UINT32)flush.GetAckingNodeId(i));
}
PLOG(PL_ALWAYS, " ");
}
break;
}
case NormCmdMsg::CC:
{
const NormCmdCCMsg& cc = static_cast<const NormCmdCCMsg&>(msg);
PLOG(PL_ALWAYS, " seq>%u ", cc.GetCCSequence());
NormHeaderExtension ext;
while (cc.GetNextExtension(ext))
{
if (NormHeaderExtension::CC_RATE == ext.GetType())
{
UINT16 sendRate = ((NormCCRateExtension&)ext).GetSendRate();
PLOG(PL_ALWAYS, " rate>%f ", 8.0e-03 * NormUnquantizeRate(sendRate));
break;
}
}
struct timeval sendTime;
cc.GetSendTime(sendTime);
double delay = ProtoTime::Delta(ProtoTime(currentTime), ProtoTime(sendTime));
PLOG(PL_ALWAYS, "delay>%lf ", delay);
break;
}
default:
break;
}
break;
}
case NormMsg::ACK:
case NormMsg::NACK:
{ {
PLOG(PL_ALWAYS, "%s ", MSG_NAME[msgType]); int index = ((const NormCmdAckReqMsg &)msg).GetAckType();
// look for NormCCFeedback extension index = MIN(index, 3);
NormHeaderExtension ext; PLOG(PL_ALWAYS, "(%s) ", REQ_NAME[index]);
while (msg.GetNextExtension(ext))
{
if (NormHeaderExtension::CC_FEEDBACK == ext.GetType())
{
clrFlag = ((NormCCFeedbackExtension&)ext).CCFlagIsSet(NormCC::CLR);
// Print ccRtt (only valid if pcap file is from sender node)
double ccRtt = NormUnquantizeRtt(((NormCCFeedbackExtension&)ext).GetCCRtt());
double ccLoss = NormUnquantizeLoss32(((NormCCFeedbackExtension&)ext).GetCCLoss32());
PLOG(PL_ALWAYS, "ccRtt:%lf ccLoss:%lf ", ccRtt, ccLoss);
break;
}
}
// Print locally measured rtt (only valid if pcap file is from sender node)
struct timeval grttResponse;
if (NormMsg::NACK == msgType)
static_cast<const NormNackMsg&>(msg).GetGrttResponse(grttResponse);
else
static_cast<const NormAckMsg&>(msg).GetGrttResponse(grttResponse);
double rtt = ProtoTime::Delta(ProtoTime(currentTime), ProtoTime(grttResponse));
PLOG(PL_ALWAYS, "rtt:%lf ", rtt);
PLOG(PL_ALWAYS, "len>%hu %s\n", length, clrFlag ? "(CLR)" : "");
if (NormMsg::NACK == msgType)
{
const NormNackMsg& nack = static_cast<const NormNackMsg&>(msg);
PLOG(PL_ALWAYS, "repair content for sender id 0x%08x)\n", nack.GetSenderId());
LogRepairContent(nack.GetRepairContent(), nack.GetRepairContentLength(), lastFecId, fecM);
}
return;
break; break;
} }
case NormCmdMsg::SQUELCH:
default: {
PLOG(PL_ALWAYS, "%s ", MSG_NAME[msgType]); const NormCmdSquelchMsg &squelch =
static_cast<const NormCmdSquelchMsg &>(msg);
PLOG(PL_ALWAYS, " obj>%hu blk>%lu seg>%hu ",
(UINT16)squelch.GetObjectId(),
(UINT32)squelch.GetFecBlockId(fecM).GetValue(),
(UINT16)squelch.GetFecSymbolId(fecM));
break; break;
} }
PLOG(PL_ALWAYS, "len>%hu %s\n", length, clrFlag ? "(CLR)" : ""); case NormCmdMsg::FLUSH:
} // end NormTrace2(); {
const NormCmdFlushMsg &flush =
static_cast<const NormCmdFlushMsg &>(msg);
PLOG(PL_ALWAYS, " obj>%hu blk>%lu seg>%hu ",
(UINT16)flush.GetObjectId(),
(UINT32)flush.GetFecBlockId(fecM).GetValue(),
(UINT16)flush.GetFecSymbolId(fecM));
// Print acking node list (if any)
UINT16 nodeCount = flush.GetAckingNodeCount();
if (nodeCount > 0)
{
PLOG(PL_ALWAYS, "ackers>");
for (UINT16 i = 0; i < nodeCount; i++)
{
if (i > 0)
PLOG(PL_ALWAYS, ",");
PLOG(PL_ALWAYS, "0x%08x", (UINT32)flush.GetAckingNodeId(i));
}
PLOG(PL_ALWAYS, " ");
}
break;
}
case NormCmdMsg::CC:
{
const NormCmdCCMsg &cc = static_cast<const NormCmdCCMsg &>(msg);
PLOG(PL_ALWAYS, " seq>%u ", cc.GetCCSequence());
NormHeaderExtension ext;
while (cc.GetNextExtension(ext))
{
if (NormHeaderExtension::CC_RATE == ext.GetType())
{
UINT16 sendRate = ((NormCCRateExtension &)ext).GetSendRate();
PLOG(PL_ALWAYS, " rate>%f ", 8.0e-03 * NormUnquantizeRate(sendRate));
break;
}
}
struct timeval sendTime;
cc.GetSendTime(sendTime);
double delay = ProtoTime::Delta(ProtoTime(currentTime), ProtoTime(sendTime));
PLOG(PL_ALWAYS, "delay>%lf ", delay);
break;
}
default:
break;
}
break;
}
case NormMsg::ACK:
case NormMsg::NACK:
{
PLOG(PL_ALWAYS, "%s ", MSG_NAME[msgType]);
// look for NormCCFeedback extension
NormHeaderExtension ext;
while (msg.GetNextExtension(ext))
{
if (NormHeaderExtension::CC_FEEDBACK == ext.GetType())
{
clrFlag = ((NormCCFeedbackExtension &)ext).CCFlagIsSet(NormCC::CLR);
// Print ccRtt (only valid if pcap file is from sender node)
double ccRtt = NormUnquantizeRtt(((NormCCFeedbackExtension &)ext).GetCCRtt());
double ccLoss = NormUnquantizeLoss32(((NormCCFeedbackExtension &)ext).GetCCLoss32());
PLOG(PL_ALWAYS, "ccRtt:%lf ccLoss:%lf ", ccRtt, ccLoss);
break;
}
}
// Print locally measured rtt (only valid if pcap file is from sender node)
struct timeval grttResponse;
if (NormMsg::NACK == msgType)
static_cast<const NormNackMsg &>(msg).GetGrttResponse(grttResponse);
else
static_cast<const NormAckMsg &>(msg).GetGrttResponse(grttResponse);
double rtt = ProtoTime::Delta(ProtoTime(currentTime), ProtoTime(grttResponse));
PLOG(PL_ALWAYS, "rtt:%lf ", rtt);
PLOG(PL_ALWAYS, "len>%hu %s\n", length, clrFlag ? "(CLR)" : "");
if (NormMsg::NACK == msgType)
{
const NormNackMsg &nack = static_cast<const NormNackMsg &>(msg);
PLOG(PL_ALWAYS, "repair content for sender id 0x%08x)\n", nack.GetSenderId());
LogRepairContent(nack.GetRepairContent(), nack.GetRepairContentLength(), lastFecId, fecM);
}
return;
break;
}
default:
PLOG(PL_ALWAYS, "%s ", MSG_NAME[msgType]);
break;
}
PLOG(PL_ALWAYS, "len>%hu %s\n", length, clrFlag ? "(CLR)" : "");
} // end NormTrace2();

2
src/unix/unixPostProcess.cpp
View File

@ -38,7 +38,7 @@
*/ */
// Some portions of this code // Some portions of this code
// Copyright © 1996 Netscape Communications Corporation, // Copyright <EFBFBD> 1996 Netscape Communications Corporation,
// all rights reserved. // all rights reserved.
#include "normPostProcess.h" #include "normPostProcess.h"