Diff: udp/udp.c

Revision:

138:5ff0c7069300

Parent:

121:bc048b65a630

Child:

142:a8c0890a58d1

--- a/udp/udp.c	Sun Apr 07 11:05:16 2019 +0000
+++ b/udp/udp.c	Sun Apr 07 18:36:42 2019 +0000
@@ -19,28 +19,56 @@
 
 bool UdpTrace = true;
 
-__packed struct header
+static char* hdrPtrSrcPort    (char* pPacket) { return pPacket + 0; } //2
+static char* hdrPtrDstPort    (char* pPacket) { return pPacket + 2; } //2
+static char* hdrPtrTotalLength(char* pPacket) { return pPacket + 4; } //2
+static char* hdrPtrChecksum   (char* pPacket) { return pPacket + 6; } //2
+static const int HEADER_LENGTH = 8;
+
+void UdpHdrSetChecksum(void* pPacket, uint16_t checksum)
 {
-    uint16_t srcPort;
-    uint16_t dstPort;
-    uint16_t totalLength;
-    uint16_t checksum;
-};
+    NetDirect16(hdrPtrChecksum(pPacket), &checksum);
+}
 static uint16_t     srcPort;
 static uint16_t     dstPort;
 static uint16_t    checksum;
 static uint16_t totalLength;
 
-static void readHeader(void* pPacket, uint16_t size)
+static void readHeader(char* pPacket)
+{
+    NetInvert16(&srcPort,     hdrPtrSrcPort    (pPacket));
+    NetInvert16(&dstPort,     hdrPtrDstPort    (pPacket));
+    NetDirect16(&checksum,    hdrPtrChecksum   (pPacket));
+    NetInvert16(&totalLength, hdrPtrTotalLength(pPacket));
+}
+void UdpMakeHeader(int size, char* pPacket)
 {
-    struct header* pHeader = (struct header*)pPacket;
-    
-    srcPort     = NetToHost16(pHeader->srcPort);
-    dstPort     = NetToHost16(pHeader->dstPort);
-    totalLength = NetToHost16(pHeader->totalLength);
-    checksum    = NetToHost16(pHeader->checksum);
+    checksum = 0;
+    NetInvert16(hdrPtrSrcPort    (pPacket), &srcPort    );
+    NetInvert16(hdrPtrDstPort    (pPacket), &dstPort    );
+    NetDirect16(hdrPtrChecksum   (pPacket), &checksum   );
+    NetInvert16(hdrPtrTotalLength(pPacket), &size       );
+
 }
-static int handlePort(void (*traceback)(void), int dataLengthRx, void* pDataRx, int* pPataLengthTx, void* pDataTx)
+
+void UdpLogHeader(uint16_t calculatedChecksum)
+{
+    if (NetTraceVerbose)
+    {
+        Log ("UDP header\r\n");
+        LogF("  Source port      %hu\r\n", srcPort);
+        LogF("  Destination port %hu\r\n", dstPort);
+        LogF("  Total length     %hu\r\n", totalLength);
+        LogF("  Checksum (hex)   %04hX\r\n", checksum);
+        LogF("  Calculated       %04hX\r\n", calculatedChecksum);
+    }
+    else
+    {
+        LogF("UDP   header %hu >>> %hu\r\n", srcPort, dstPort);
+    }
+}
+
+static int handlePort(void (*traceback)(void), int dataLengthRx, char* pDataRx, int* pPataLengthTx, char* pDataTx)
 {
     switch (dstPort)
     {
@@ -83,21 +111,21 @@
             return DO_NOTHING;
     }
 }
-int UdpHandleReceivedPacket(void (*traceback)(void), int sizeRx, void* pPacketRx, int* pSizeTx, void* pPacketTx)
+int UdpHandleReceivedPacket(void (*traceback)(void), int sizeRx, char* pPacketRx, int* pSizeTx, char* pPacketTx)
 {    
     int lastFaultPoint = FaultPoint;
     FaultPoint = FAULT_POINT_UdpHandleReceivedPacket;
     
-    readHeader(pPacketRx, sizeRx);
+    readHeader(pPacketRx);
 
-    void* pDataRx    = (char*)pPacketRx + sizeof(struct header);
-    void* pDataTx    = (char*)pPacketTx + sizeof(struct header);
-    int dataLengthRx =           sizeRx - sizeof(struct header);
-    int dataLengthTx =         *pSizeTx - sizeof(struct header);
+    void* pDataRx    = pPacketRx + HEADER_LENGTH;
+    void* pDataTx    = pPacketTx + HEADER_LENGTH;
+    int dataLengthRx =    sizeRx - HEADER_LENGTH;
+    int dataLengthTx =  *pSizeTx - HEADER_LENGTH;
     
     int action = handlePort(traceback, dataLengthRx, pDataRx, &dataLengthTx, pDataTx);
     
-    *pSizeTx = dataLengthTx + sizeof(struct header);
+    *pSizeTx = dataLengthTx + HEADER_LENGTH;
     
     uint16_t tmpPort = dstPort;
     dstPort = srcPort;
@@ -106,7 +134,7 @@
     FaultPoint = lastFaultPoint;
     return action;
 }
-static int pollForPacketToSend(int type, int* pDataLength, void* pData)
+static int pollForPacketToSend(int type, int* pDataLength, char* pData)
 {
     int action = DO_NOTHING;
     
@@ -160,46 +188,13 @@
     
     return action;
 }
-int UdpPollForPacketToSend(int type, int* pSize, void* pPacket)
+int UdpPollForPacketToSend(int type, int* pSize, char* pPacket)
 {
-    void* pData    = (char*)pPacket + sizeof(struct header);
-    int dataLength =         *pSize - sizeof(struct header);
+    void* pData    = pPacket + HEADER_LENGTH;
+    int dataLength =  *pSize - HEADER_LENGTH;
     
     int action = pollForPacketToSend(type, &dataLength, pData);
     
-    *pSize = dataLength + sizeof(struct header);
+    *pSize = dataLength + HEADER_LENGTH;
     return action;
 }
-
-void UdpLogHeader(uint16_t calculatedChecksum)
-{
-    if (NetTraceVerbose)
-    {
-        Log ("UDP header\r\n");
-        LogF("  Source port      %hu\r\n", srcPort);
-        LogF("  Destination port %hu\r\n", dstPort);
-        LogF("  Total length     %hu\r\n", totalLength);
-        LogF("  Checksum (hex)   %04hX\r\n", checksum);
-        LogF("  Calculated       %04hX\r\n", calculatedChecksum);
-    }
-    else
-    {
-        LogF("UDP   header %hu >>> %hu\r\n", srcPort, dstPort);
-    }
-}
-
-void UdpMakeHeader(int size, void* pPacket)
-{        
-    struct header* pHeader = (struct header*)pPacket;
-    
-    pHeader->dstPort     = NetToHost16(dstPort);
-    pHeader->srcPort     = NetToHost16(srcPort);
-    pHeader->totalLength = NetToHost16(size);
-    pHeader->checksum    = 0;
-
-}
-void UdpAddChecksum(void* pPacket, uint16_t checksum)
-{
-    struct header* pHeader = (struct header*)pPacket;
-    pHeader->checksum    = checksum;
-}