Diff: eth/eth.c

Revision:

136:8a65abb0dc63

Parent:

98:b977424ec7f7

Child:

142:a8c0890a58d1

--- a/eth/eth.c	Sat Mar 23 12:25:48 2019 +0000
+++ b/eth/eth.c	Sat Apr 06 11:20:20 2019 +0000
@@ -13,13 +13,13 @@
 #define MTU 1500
 
 //header variables
-__packed struct header
-{
-    char     dst[6];
-    char     src[6];
-    uint16_t typ;
-};
-static uint16_t protocol;
+static char*    hdrDstPtr(char* pPacket) { return pPacket +  0; }
+static char*    hdrSrcPtr(char* pPacket) { return pPacket +  6; }
+static char*    hdrTypPtr(char* pPacket) { return pPacket + 12; }
+#define HEADER_LENGTH 14
+static uint16_t hdrTypGet(char* pPacket) { uint16_t res;     NetInvert16(&res, hdrTypPtr(pPacket)        ); return res; }
+static void     hdrTypSet(char* pPacket,   uint16_t value) { NetInvert16(      hdrTypPtr(pPacket), &value); }
+
 void EthProtocolLog(uint16_t prototype)
 {
     switch (prototype)
@@ -30,64 +30,58 @@
         default:   LogF("%04hX", prototype); break;
     }
 }
-void LogHeader(struct header* pHeader)
+void LogHeader(char* pPacket)
 {
     if (NetTraceVerbose)
     {
         Log("ETH header\r\n");
-        Log("  Destination:  ");         MacLog(pHeader->dst);              Log("\r\n");
-        Log("  Source:       ");         MacLog(pHeader->src);              Log("\r\n");
-        Log("  EtherType:    "); EthProtocolLog(NetToHost16(pHeader->typ)); Log("\r\n");        
+        Log("  Destination:  ");         MacLog(hdrDstPtr(pPacket)); Log("\r\n");
+        Log("  Source:       ");         MacLog(hdrSrcPtr(pPacket)); Log("\r\n");
+        Log("  EtherType:    "); EthProtocolLog(hdrTypGet(pPacket)); Log("\r\n");        
     }
     else
     {
         Log("ETH   header ");
-        EthProtocolLog(NetToHost16(pHeader->typ));
+        EthProtocolLog(hdrTypGet(pPacket));
         Log(" ");
-        MacLog(pHeader->src);
+        MacLog(hdrSrcPtr(pPacket));
         Log(" >>> ");
-        MacLog(pHeader->dst);
+        MacLog(hdrDstPtr(pPacket));
         Log("\r\n");
     }
 }
-static void* tracePacket;
-static void trace()
-{
-    struct header * pHeader = (struct header*)tracePacket;
-    LogHeader(pHeader);
-}
-int EthHandlePacket(void* pPacketRx, int sizeRx, void* pPacketTx, int* pSizeTx)
+static char* tracePacket;
+static void trace() { LogHeader(tracePacket); }
+int EthHandlePacket(char* pPacketRx, int sizeRx, char* pPacketTx, int* pSizeTx)
 {
     int lastFaultPoint = FaultPoint;
     FaultPoint = FAULT_POINT_EthHandlePacket;
     
     tracePacket = pPacketRx;
     
-    struct header * pHeaderRx = (struct header*)pPacketRx;
-    struct header * pHeaderTx = (struct header*)pPacketTx;
-    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);
+    char* pDataRx    = pPacketRx + HEADER_LENGTH;
+    char* pDataTx    = pPacketTx + HEADER_LENGTH;
+    int dataLengthRx =    sizeRx - HEADER_LENGTH;
+    int dataLengthTx =  *pSizeTx - HEADER_LENGTH;
     if (dataLengthTx > MTU) dataLengthTx = MTU; //Limit the transmitted length to the maximum ethernet frame payload length
         
-    if (!MacAccept(pHeaderRx->dst))
+    if (!MacAccept(hdrDstPtr(pPacketRx)))
     {
         FaultPoint = lastFaultPoint;
         return DO_NOTHING;
     }
     
-    protocol = NetToHost16(pHeaderRx->typ);
+    uint16_t protocol = hdrTypGet(pPacketRx);
     if (protocol < 1500)
     {
         FaultPoint = lastFaultPoint;
         return DO_NOTHING; //drop 802.3 messages
     }
 
-    NetTraceHostCheckMac(pHeaderRx->src);
+    NetTraceHostCheckMac(hdrSrcPtr(pPacketRx));
 
     int   action = DO_NOTHING;
-    char* macRemote = pHeaderRx->src;
+    char* macRemote = hdrSrcPtr(pPacketRx);
     switch (protocol)
     {
         case ARP:  action = ArpHandleReceivedPacket(trace, pDataRx, dataLengthRx, pDataTx, &dataLengthTx);            break;
@@ -110,26 +104,25 @@
     }
         
     MacMakeFromDest(ActionGetDestPart(action), protocol, macRemote);
-    MacCopy(pHeaderTx->src, MacLocal);
-    MacCopy(pHeaderTx->dst, macRemote);
-    pHeaderTx->typ = NetToHost16(protocol);
+    MacCopy(hdrSrcPtr(pPacketTx), MacLocal);
+    MacCopy(hdrDstPtr(pPacketTx), macRemote);
+    hdrTypSet(pPacketTx, protocol);
     
-    *pSizeTx = sizeof(struct header) + dataLengthTx;
+    *pSizeTx = HEADER_LENGTH + dataLengthTx;
     
-    if (ActionGetTracePart(action)) LogHeader(pHeaderTx);
+    if (ActionGetTracePart(action)) LogHeader(pPacketTx);
     
     FaultPoint = lastFaultPoint;
     return action;
 }
-int EthPollForPacketToSend(void* pPacket, int* pSize)
+int EthPollForPacketToSend(char* pPacket, int* pSize)
 {
-    struct header * pHeader = (struct header*)pPacket;
-    void* pData = (char*)pPacket + sizeof(struct header);
+    char* pData    = pPacket + HEADER_LENGTH;
+    int dataLength =  *pSize - HEADER_LENGTH;
+    if (dataLength > MTU) dataLength = MTU; //Limit the transmitted length to the maximum ethernet frame payload length
     
-    int dataLength = *pSize - sizeof(struct header);
-    if (dataLength > MTU) dataLength = MTU; //Limit the transmitted length to the maximum ethernet frame payload length
-    protocol = 0;
     int action = DO_NOTHING;
+    uint16_t protocol = 0;
     if (!action)
     {
         action = ArpPollForPacketToSend(pData, &dataLength);
@@ -138,25 +131,25 @@
 
     if (!action)
     {
-        action = Ip6PollForPacketToSend(pData, &dataLength, pHeader->dst);
+        action = Ip6PollForPacketToSend(pData, &dataLength, hdrDstPtr(pPacket));
         protocol = IPV6;
     }
     
     if (!action)
     {
-        action = Ip4PollForPacketToSend(pData, &dataLength, pHeader->dst);
+        action = Ip4PollForPacketToSend(pData, &dataLength, hdrDstPtr(pPacket));
         protocol = IPV4;
     }
     
     if (!action) return DO_NOTHING;
     
-    MacMakeFromDest(ActionGetDestPart(action), protocol, pHeader->dst);
-    MacCopy(pHeader->src, MacLocal);
-    pHeader->typ = NetToHost16(protocol);
+    MacMakeFromDest(ActionGetDestPart(action), protocol, hdrDstPtr(pPacket));
+    MacCopy(hdrSrcPtr(pPacket), MacLocal);
+    hdrTypSet(pPacket, protocol);
     
-    *pSize = sizeof(struct header) + dataLength;
+    *pSize = HEADER_LENGTH + dataLength;
     
-    if (ActionGetTracePart(action)) LogHeader(pHeader);
+    if (ActionGetTracePart(action)) LogHeader(pPacket);
     
     return action;
 }