[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

CMakeLists.txt

@@ -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()
+

cmake/normConfig.cmake.in

@@ -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")

examples/normCast.cpp

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

examples/normFileRecv.cpp

@@ -63,7 +63,7 @@ int main(int argc, char* argv[])
     
     // NOTE: These are debugging routines available 
     //       (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);
     // Uncomment to turn on debug NORM message tracing
     //NormSetMessageTrace(session, true);

examples/normFileSend.cpp

@@ -71,7 +71,7 @@ int main(int argc, char* argv[])
     
     // NOTE: These are some debugging routines available 
     //       (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);
     // Uncomment to turn on debug NORM message tracing
     NormSetMessageTrace(session, true);

examples/normStreamRecv.cpp

@@ -48,7 +48,7 @@ int main(int argc, char* argv[])
     
     // NOTE: These are debugging routines available 
     //       (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);
     // Uncomment to turn on debug NORM message tracing
     NormSetMessageTrace(session, true);

examples/wintest.cpp

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

src/common/normFile.cpp

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

src/common/pcap2norm.cpp

@@ -2,7 +2,6 @@
 // Assumes UDP packets in tcpdump trace file (pcap file) are
 // MGEN packets and parses to build an MGEN log file
 
-
 #include <stdio.h>
 #include <pcap.h>
 #include <sys/socket.h>  // for PF_ types (protocol family)
@@ -12,21 +11,21 @@
 
 #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()
 {
     fprintf(stderr, "pcap2norm [pcapInputFile [outputFile]]\n");
 }
 
-int main(int argc, char* argv[])
+int main(int argc, char *argv[])
 {
     // Use stdin/stdout by default
-    FILE* infile = stdin;
+    FILE *infile = stdin;
-    FILE* outfile = stdout;
+    FILE *outfile = stdout;
-    switch(argc)
+    switch (argc)
     {
     case 1:
         // using default stdin/stdout
@@ -58,32 +57,35 @@ int main(int argc, char* argv[])
         return -1;
     } // end switch(argc)
 
-    char pcapErrBuf[PCAP_ERRBUF_SIZE+1];
+    char pcapErrBuf[PCAP_ERRBUF_SIZE + 1];
     pcapErrBuf[PCAP_ERRBUF_SIZE] = '\0';
-    pcap_t* pcapDevice = pcap_fopen_offline(infile, pcapErrBuf);
+    pcap_t *pcapDevice = pcap_fopen_offline(infile, pcapErrBuf);
     if (NULL == pcapDevice)
     {
         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;
     }
 
     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
 
     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;
-        if (hdr.caplen < numBytes) numBytes = hdr.caplen;
+        if (hdr.caplen < numBytes)
+            numBytes = hdr.caplen;
         ProtoPktETH::Type ethType;
         unsigned int payloadLength;
-        UINT32* payloadPtr;
+        UINT32 *payloadPtr;
         if (DLT_NULL == deviceType)
         {
             // pcap was captured from "loopback" device
@@ -114,7 +116,7 @@ int main(int argc, char* argv[])
             ethType = ethPkt.GetType();
             payloadLength = ethPkt.GetPayloadLength();
             // 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();
         }
 
@@ -146,7 +148,7 @@ int main(int argc, char* argv[])
             }
             default:
             {
-                    PLOG(PL_ERROR,"pcap2norm Error: Invalid IP pkt version.\n");
+                PLOG(PL_ERROR, "pcap2norm Error: Invalid IP pkt version.\n");
                 break;
             }
             }
@@ -157,13 +159,15 @@ int main(int argc, char* argv[])
         {
             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;
-        if (!udpPkt.InitFromPacket(ipPkt)) continue;  // not a UDP packet
+        if (!udpPkt.InitFromPacket(ipPkt))
+            continue; // not a UDP packet
 
         NormMsg msg;
-        if (msg.CopyFromBuffer((const char*)udpPkt.GetPayload(), udpPkt.GetPayloadLength()))
+        if (msg.CopyFromBuffer((const char *)udpPkt.GetPayload(), udpPkt.GetPayloadLength()))
         {
             srcAddr.SetPort(udpPkt.GetSrcPort());
             msg.AccessAddress() = srcAddr;
@@ -178,18 +182,17 @@ int main(int argc, char* argv[])
 
 } // end main()
 
-
 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
 
-    static const char* MSG_NAME[] =
+    static const char *MSG_NAME[] =
         {
             "INVALID",
             "INFO",
@@ -197,9 +200,8 @@ void NormTrace2(const struct timeval&    currentTime,
             "CMD",
             "NACK",
             "ACK",
-        "REPORT"
+            "REPORT"};
-    };       
+    static const char *CMD_NAME[] =
-    static const char* CMD_NAME[] =
         {
             "CMD(INVALID)",
             "CMD(FLUSH)",
@@ -208,15 +210,13 @@ void NormTrace2(const struct timeval&    currentTime,
             "CMD(CC)",
             "CMD(REPAIR_ADV)",
             "CMD(ACK_REQ)",
-        "CMD(APP)"
+            "CMD(APP)"};
-    };            
+    static const char *REQ_NAME[] =
-    static const char* REQ_NAME[] = 
         {
             "INVALID",
             "WATERMARK",
             "RTT",
-        "APP"
+            "APP"};
-    };
 
     NormMsg::Type msgType = msg.GetType();
     UINT16 length = msg.GetLength();
@@ -226,22 +226,19 @@ void NormTrace2(const struct timeval&    currentTime,
     srcAddr.GetHostString(src, 63);
     dstAddr.GetHostString(dst, 63);
 
-
-
 #ifdef _WIN32_WCE
     struct tm timeStruct;
     timeStruct.tm_hour = currentTime.tv_sec / 3600;
     unsigned long hourSecs = 3600 * timeStruct.tm_hour;
     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;
-    struct tm* ct = &timeStruct;
+    struct tm *ct = &timeStruct;
 #else
     time_t secs = (time_t)currentTime.tv_sec;
-    struct tm* ct = gmtime(&secs);
+    struct tm *ct = gmtime(&secs);
 #endif // if/else _WIN32_WCE
 
-    
     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);
     PLOG(PL_ALWAYS, "src>%s/%hu dst>%s/%hu id>0x%08x ", src, srcAddr.GetPort(), dst, dstAddr.GetPort(), (UINT32)msg.GetSourceId());
@@ -251,7 +248,7 @@ void NormTrace2(const struct timeval&    currentTime,
     {
     case NormMsg::INFO:
     {
-            const NormInfoMsg& info = (const NormInfoMsg&)msg;
+        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());
@@ -259,7 +256,7 @@ void NormTrace2(const struct timeval&    currentTime,
     }
     case NormMsg::DATA:
     {
-            const NormDataMsg& data = (const NormDataMsg&)msg;
+        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(),
@@ -292,22 +289,22 @@ void NormTrace2(const struct timeval&    currentTime,
     }
     case NormMsg::CMD:
     {
-            const NormCmdMsg& cmd = static_cast<const NormCmdMsg&>(msg);
+        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)
         {
         case NormCmdMsg::ACK_REQ:
         {
-                    int index = ((const NormCmdAckReqMsg&)msg).GetAckType();
+            int index = ((const NormCmdAckReqMsg &)msg).GetAckType();
             index = MIN(index, 3);
             PLOG(PL_ALWAYS, "(%s) ", REQ_NAME[index]);
             break;
         }
         case NormCmdMsg::SQUELCH:
         {
-                    const NormCmdSquelchMsg& squelch = 
+            const NormCmdSquelchMsg &squelch =
-                        static_cast<const NormCmdSquelchMsg&>(msg);
+                static_cast<const NormCmdSquelchMsg &>(msg);
             PLOG(PL_ALWAYS, " obj>%hu blk>%lu seg>%hu ",
                  (UINT16)squelch.GetObjectId(),
                  (UINT32)squelch.GetFecBlockId(fecM).GetValue(),
@@ -316,8 +313,8 @@ void NormTrace2(const struct timeval&    currentTime,
         }
         case NormCmdMsg::FLUSH:
         {
-                    const NormCmdFlushMsg& flush = 
+            const NormCmdFlushMsg &flush =
-                        static_cast<const NormCmdFlushMsg&>(msg);
+                static_cast<const NormCmdFlushMsg &>(msg);
             PLOG(PL_ALWAYS, " obj>%hu blk>%lu seg>%hu ",
                  (UINT16)flush.GetObjectId(),
                  (UINT32)flush.GetFecBlockId(fecM).GetValue(),
@@ -330,8 +327,9 @@ void NormTrace2(const struct timeval&    currentTime,
                 PLOG(PL_ALWAYS, "ackers>");
                 for (UINT16 i = 0; i < nodeCount; i++)
                 {
-                            if (i > 0) PLOG(PL_ALWAYS, ",");
+                    if (i > 0)
-                            PLOG(PL_ALWAYS,"0x%08x", (UINT32)flush.GetAckingNodeId(i));
+                        PLOG(PL_ALWAYS, ",");
+                    PLOG(PL_ALWAYS, "0x%08x", (UINT32)flush.GetAckingNodeId(i));
                 }
                 PLOG(PL_ALWAYS, " ");
             }
@@ -339,14 +337,14 @@ void NormTrace2(const struct timeval&    currentTime,
         }
         case NormCmdMsg::CC:
         {
-                    const NormCmdCCMsg& cc = static_cast<const NormCmdCCMsg&>(msg);
+            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();       
+                    UINT16 sendRate = ((NormCCRateExtension &)ext).GetSendRate();
                     PLOG(PL_ALWAYS, " rate>%f ", 8.0e-03 * NormUnquantizeRate(sendRate));
                     break;
                 }
@@ -373,10 +371,10 @@ void NormTrace2(const struct timeval&    currentTime,
         {
             if (NormHeaderExtension::CC_FEEDBACK == ext.GetType())
             {
-                    clrFlag = ((NormCCFeedbackExtension&)ext).CCFlagIsSet(NormCC::CLR);
+                clrFlag = ((NormCCFeedbackExtension &)ext).CCFlagIsSet(NormCC::CLR);
                 // Print ccRtt (only valid if pcap file is from sender node)
-                    double ccRtt = NormUnquantizeRtt(((NormCCFeedbackExtension&)ext).GetCCRtt());
+                double ccRtt = NormUnquantizeRtt(((NormCCFeedbackExtension &)ext).GetCCRtt());
-                    double ccLoss = NormUnquantizeLoss32(((NormCCFeedbackExtension&)ext).GetCCLoss32());
+                double ccLoss = NormUnquantizeLoss32(((NormCCFeedbackExtension &)ext).GetCCLoss32());
                 PLOG(PL_ALWAYS, "ccRtt:%lf ccLoss:%lf ", ccRtt, ccLoss);
                 break;
             }
@@ -384,9 +382,9 @@ void NormTrace2(const struct timeval&    currentTime,
         // 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);
+            static_cast<const NormNackMsg &>(msg).GetGrttResponse(grttResponse);
         else
-                static_cast<const NormAckMsg&>(msg).GetGrttResponse(grttResponse);
+            static_cast<const NormAckMsg &>(msg).GetGrttResponse(grttResponse);
 
         double rtt = ProtoTime::Delta(ProtoTime(currentTime), ProtoTime(grttResponse));
         PLOG(PL_ALWAYS, "rtt:%lf ", rtt);
@@ -394,7 +392,7 @@ void NormTrace2(const struct timeval&    currentTime,
         PLOG(PL_ALWAYS, "len>%hu %s\n", length, clrFlag ? "(CLR)" : "");
         if (NormMsg::NACK == msgType)
         {
-                const NormNackMsg& nack = static_cast<const NormNackMsg&>(msg);
+            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);
         }
@@ -408,4 +406,3 @@ void NormTrace2(const struct timeval&    currentTime,
     }
     PLOG(PL_ALWAYS, "len>%hu %s\n", length, clrFlag ? "(CLR)" : "");
 } // end NormTrace2();
-

src/unix/unixPostProcess.cpp

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