MCHPStack2.20/Source/arp.c

/*********************************************************************
 *
 *                  ARP Module for Microchip TCP/IP Stack
 *
 *********************************************************************
 * FileName:        ARP.c
 * Dependencies:    string.h
 *                  stacktsk.h
 *                  helpers.h
 *                  arp.h
 *                  mac.h
 * Processor:       PIC18
 * Complier:        MCC18 v1.00.50 or higher
 *                  HITECH PICC-18 V8.10PL1 or higher
 * Company:         Microchip Technology, Inc.
 *
 * Software License Agreement
 *
 * The software supplied herewith by Microchip Technology Incorporated
 * (the “Company”) for its PICmicro® Microcontroller is intended and
 * supplied to you, the Company’s customer, for use solely and
 * exclusively on Microchip PICmicro Microcontroller products. The
 * software is owned by the Company and/or its supplier, and is
 * protected under applicable copyright laws. All rights are reserved.
 * Any use in violation of the foregoing restrictions may subject the
 * user to criminal sanctions under applicable laws, as well as to
 * civil liability for the breach of the terms and conditions of this
 * license.
 *
 * THIS SOFTWARE IS PROVIDED IN AN “AS IS” CONDITION. NO WARRANTIES,
 * WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT NOT LIMITED
 * TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 * PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. THE COMPANY SHALL NOT,
 * IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL OR
 * CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER.
 *
 * HiTech PICC18 Compiler Options excluding device selection:
 *                  -FAKELOCAL -G -Zg -E -C
 *
 * Author               Date    Comment
 *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 * Nilesh Rajbharti     5/1/01  Original        (Rev 1.0)
 * Nilesh Rajbharti     2/9/02  Cleanup
 * Nilesh Rajbharti     5/22/02 Rev 2.0 (See version.log for detail)
 ********************************************************************/
#include <string.h>

#include "stacktsk.h"
#include "helpers.h"
#include "arp.h"
#include "mac.h"

/*
 * ARP Operation codes.
 */
#define ARP_OPERATION_REQ       0x01
#define ARP_OPERATION_RESP      0x02

/*
 * ETHERNET packet type as defined by IEEE 802.3
 */
#define HW_ETHERNET             (0x0001)
#define ARP_IP                  (0x0800)


/*
 * ARP packet
 */
typedef struct _ARP_PACKET
{
    WORD        HardwareType;
    WORD        Protocol;
    BYTE        MACAddrLen;
    BYTE        ProtocolLen;
    WORD        Operation;
    MAC_ADDR    SenderMACAddr;
    IP_ADDR     SenderIPAddr;
    MAC_ADDR    TargetMACAddr;
    IP_ADDR     TargetIPAddr;
} ARP_PACKET;

static void SwapARPPacket(ARP_PACKET *p);


/*********************************************************************
 * Function:        BOOL ARPGet(NODE_INFO* remote, BYTE* opCode)
 *
 * PreCondition:    ARP packet is ready in MAC buffer.
 *
 * Input:           remote  - Remote node info
 *                  opCode  - Buffer to hold ARP op code.
 *
 * Output:          TRUE if a valid ARP packet was received.
 *                  FALSE otherwise.
 *
 * Side Effects:    None
 *
 * Overview:        None
 *
 * Note:            None
 ********************************************************************/
BOOL ARPGet(NODE_INFO *remote, BYTE *opCode)
{
    ARP_PACKET packet;

    MACGetArray((BYTE*)&packet, sizeof(packet));

    MACDiscardRx();

    SwapARPPacket(&packet);

    if ( packet.HardwareType != HW_ETHERNET     ||
         packet.MACAddrLen != sizeof(MAC_ADDR)  ||
         packet.ProtocolLen != sizeof(IP_ADDR) )
         return FALSE;

    if ( packet.Operation == ARP_OPERATION_RESP )
        *opCode = ARP_REPLY;
    else if ( packet.Operation == ARP_OPERATION_REQ )
        *opCode = ARP_REQUEST;
    else
    {
        *opCode = ARP_UNKNOWN;
        return FALSE;
    }

    if ( (packet.TargetIPAddr.v[0] == MY_IP_BYTE1) &&
         (packet.TargetIPAddr.v[1] == MY_IP_BYTE2) &&
         (packet.TargetIPAddr.v[2] == MY_IP_BYTE3) &&
         (packet.TargetIPAddr.v[3] == MY_IP_BYTE4) )
    {
        remote->MACAddr     = packet.SenderMACAddr;
        remote->IPAddr      = packet.SenderIPAddr;
        return TRUE;
    }
    else
        return FALSE;
}


/*********************************************************************
 * Function:        void ARPPut(NODE_INFO* more, BYTE opCode)
 *
 * PreCondition:    MACIsTxReady() == TRUE
 *
 * Input:           remote  - Remote node info
 *                  opCode  - ARP op code to send
 *
 * Output:          None
 *
 * Side Effects:    None
 *
 * Overview:        None
 *
 * Note:            None
 ********************************************************************/
void ARPPut(NODE_INFO *remote,
            BYTE opCode)
{
    ARP_PACKET packet;

    packet.HardwareType             = HW_ETHERNET;
    packet.Protocol                 = ARP_IP;
    packet.MACAddrLen               = sizeof(MAC_ADDR);
    packet.ProtocolLen              = sizeof(IP_ADDR);

    if ( opCode == ARP_REQUEST )
    {
        packet.Operation            = ARP_OPERATION_REQ;
        packet.TargetMACAddr.v[0]   = 0xff;
        packet.TargetMACAddr.v[1]   = 0xff;
        packet.TargetMACAddr.v[2]   = 0xff;
        packet.TargetMACAddr.v[3]   = 0xff;
        packet.TargetMACAddr.v[4]   = 0xff;
        packet.TargetMACAddr.v[5]   = 0xff;
    }
    else
    {
        packet.Operation            = ARP_OPERATION_RESP;
        packet.TargetMACAddr        = remote->MACAddr;
    }

    packet.SenderMACAddr.v[0]       = MY_MAC_BYTE1;
    packet.SenderMACAddr.v[1]       = MY_MAC_BYTE2;
    packet.SenderMACAddr.v[2]       = MY_MAC_BYTE3;
    packet.SenderMACAddr.v[3]       = MY_MAC_BYTE4;
    packet.SenderMACAddr.v[4]       = MY_MAC_BYTE5;
    packet.SenderMACAddr.v[5]       = MY_MAC_BYTE6;

    packet.SenderIPAddr.v[0]        = MY_IP_BYTE1;
    packet.SenderIPAddr.v[1]        = MY_IP_BYTE2;
    packet.SenderIPAddr.v[2]        = MY_IP_BYTE3;
    packet.SenderIPAddr.v[3]        = MY_IP_BYTE4;


    /*
     * Check to see if target is on same subnet, if not, find
     * Gateway MAC.
     * Once we get Gateway MAC, all access to remote host will
     * go through Gateway.
     */
    if (((packet.SenderIPAddr.v[0] ^ remote->IPAddr.v[0]) &
                                                MY_MASK_BYTE1) ||
        ((packet.SenderIPAddr.v[1] ^ remote->IPAddr.v[1]) &
                                                MY_MASK_BYTE2) ||
        ((packet.SenderIPAddr.v[2] ^ remote->IPAddr.v[2]) &
                                                MY_MASK_BYTE3) ||
        ((packet.SenderIPAddr.v[3] ^ remote->IPAddr.v[3]) &
                                                MY_MASK_BYTE4) )
    {
        packet.TargetIPAddr.v[0] = MY_GATE_BYTE1;
        packet.TargetIPAddr.v[1] = MY_GATE_BYTE2;
        packet.TargetIPAddr.v[2] = MY_GATE_BYTE3;
        packet.TargetIPAddr.v[3] = MY_GATE_BYTE4;
    }
    else
        packet.TargetIPAddr             = remote->IPAddr;

    SwapARPPacket(&packet);

    MACPutHeader(&packet.TargetMACAddr, MAC_ARP, sizeof(packet));

    MACPutArray((BYTE*)&packet, sizeof(packet));

    MACFlush();
}


/*********************************************************************
 * Function:        static void SwapARPPacket(ARP_PACKET* p)
 *
 * PreCondition:    None
 *
 * Input:           p   - ARP packet to be swapped.
 *
 * Output:          None
 *
 * Side Effects:    None
 *
 * Overview:        None
 *
 * Note:            None
 ********************************************************************/
static void SwapARPPacket(ARP_PACKET *p)
{
    p->HardwareType     = swaps(p->HardwareType);
    p->Protocol         = swaps(p->Protocol);
    p->Operation        = swaps(p->Operation);
}
1	hedin	62	/*********************************************************************
2			*
3			* ARP Module for Microchip TCP/IP Stack
4			*
5			*********************************************************************
6			* FileName: ARP.c
7			* Dependencies: string.h
8			* stacktsk.h
9			* helpers.h
10			* arp.h
11			* mac.h
12			* Processor: PIC18
13			* Complier: MCC18 v1.00.50 or higher
14			* HITECH PICC-18 V8.10PL1 or higher
15			* Company: Microchip Technology, Inc.
16			*
17			* Software License Agreement
18			*
19			* The software supplied herewith by Microchip Technology Incorporated
20			* (the “Company”) for its PICmicro® Microcontroller is intended and
21			* supplied to you, the Company’s customer, for use solely and
22			* exclusively on Microchip PICmicro Microcontroller products. The
23			* software is owned by the Company and/or its supplier, and is
24			* protected under applicable copyright laws. All rights are reserved.
25			* Any use in violation of the foregoing restrictions may subject the
26			* user to criminal sanctions under applicable laws, as well as to
27			* civil liability for the breach of the terms and conditions of this
28			* license.
29			*
30			* THIS SOFTWARE IS PROVIDED IN AN “AS IS” CONDITION. NO WARRANTIES,
31			* WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT NOT LIMITED
32			* TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
33			* PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. THE COMPANY SHALL NOT,
34			* IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL OR
35			* CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER.
36			*
37			* HiTech PICC18 Compiler Options excluding device selection:
38			* -FAKELOCAL -G -Zg -E -C
39			*
40			* Author Date Comment
41			*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
42			* Nilesh Rajbharti 5/1/01 Original (Rev 1.0)
43			* Nilesh Rajbharti 2/9/02 Cleanup
44			* Nilesh Rajbharti 5/22/02 Rev 2.0 (See version.log for detail)
45			********************************************************************/
46			#include <string.h>
47
48			#include "stacktsk.h"
49			#include "helpers.h"
50			#include "arp.h"
51			#include "mac.h"
52
53			/*
54			* ARP Operation codes.
55			*/
56			#define ARP_OPERATION_REQ 0x01
57			#define ARP_OPERATION_RESP 0x02
58
59			/*
60			* ETHERNET packet type as defined by IEEE 802.3
61			*/
62			#define HW_ETHERNET (0x0001)
63			#define ARP_IP (0x0800)
64
65
66			/*
67			* ARP packet
68			*/
69			typedef struct _ARP_PACKET
70			{
71			WORD HardwareType;
72			WORD Protocol;
73			BYTE MACAddrLen;
74			BYTE ProtocolLen;
75			WORD Operation;
76			MAC_ADDR SenderMACAddr;
77			IP_ADDR SenderIPAddr;
78			MAC_ADDR TargetMACAddr;
79			IP_ADDR TargetIPAddr;
80			} ARP_PACKET;
81
82			static void SwapARPPacket(ARP_PACKET *p);
83
84
85
86			/*********************************************************************
87			* Function: BOOL ARPGet(NODE_INFO* remote, BYTE* opCode)
88			*
89			* PreCondition: ARP packet is ready in MAC buffer.
90			*
91			* Input: remote - Remote node info
92			* opCode - Buffer to hold ARP op code.
93			*
94			* Output: TRUE if a valid ARP packet was received.
95			* FALSE otherwise.
96			*
97			* Side Effects: None
98			*
99			* Overview: None
100			*
101			* Note: None
102			********************************************************************/
103			BOOL ARPGet(NODE_INFO remote, BYTE opCode)
104			{
105			ARP_PACKET packet;
106
107			MACGetArray((BYTE*)&packet, sizeof(packet));
108
109			MACDiscardRx();
110
111			SwapARPPacket(&packet);
112
113			if ( packet.HardwareType != HW_ETHERNET \|\|
114			packet.MACAddrLen != sizeof(MAC_ADDR) \|\|
115			packet.ProtocolLen != sizeof(IP_ADDR) )
116			return FALSE;
117
118			if ( packet.Operation == ARP_OPERATION_RESP )
119			*opCode = ARP_REPLY;
120			else if ( packet.Operation == ARP_OPERATION_REQ )
121			*opCode = ARP_REQUEST;
122			else
123			{
124			*opCode = ARP_UNKNOWN;
125			return FALSE;
126			}
127
128			if ( (packet.TargetIPAddr.v[0] == MY_IP_BYTE1) &&
129			(packet.TargetIPAddr.v[1] == MY_IP_BYTE2) &&
130			(packet.TargetIPAddr.v[2] == MY_IP_BYTE3) &&
131			(packet.TargetIPAddr.v[3] == MY_IP_BYTE4) )
132			{
133			remote->MACAddr = packet.SenderMACAddr;
134			remote->IPAddr = packet.SenderIPAddr;
135			return TRUE;
136			}
137			else
138			return FALSE;
139			}
140
141
142			/*********************************************************************
143			* Function: void ARPPut(NODE_INFO* more, BYTE opCode)
144			*
145			* PreCondition: MACIsTxReady() == TRUE
146			*
147			* Input: remote - Remote node info
148			* opCode - ARP op code to send
149			*
150			* Output: None
151			*
152			* Side Effects: None
153			*
154			* Overview: None
155			*
156			* Note: None
157			********************************************************************/
158			void ARPPut(NODE_INFO *remote,
159			BYTE opCode)
160			{
161			ARP_PACKET packet;
162
163			packet.HardwareType = HW_ETHERNET;
164			packet.Protocol = ARP_IP;
165			packet.MACAddrLen = sizeof(MAC_ADDR);
166			packet.ProtocolLen = sizeof(IP_ADDR);
167
168			if ( opCode == ARP_REQUEST )
169			{
170			packet.Operation = ARP_OPERATION_REQ;
171			packet.TargetMACAddr.v[0] = 0xff;
172			packet.TargetMACAddr.v[1] = 0xff;
173			packet.TargetMACAddr.v[2] = 0xff;
174			packet.TargetMACAddr.v[3] = 0xff;
175			packet.TargetMACAddr.v[4] = 0xff;
176			packet.TargetMACAddr.v[5] = 0xff;
177			}
178			else
179			{
180			packet.Operation = ARP_OPERATION_RESP;
181			packet.TargetMACAddr = remote->MACAddr;
182			}
183
184			packet.SenderMACAddr.v[0] = MY_MAC_BYTE1;
185			packet.SenderMACAddr.v[1] = MY_MAC_BYTE2;
186			packet.SenderMACAddr.v[2] = MY_MAC_BYTE3;
187			packet.SenderMACAddr.v[3] = MY_MAC_BYTE4;
188			packet.SenderMACAddr.v[4] = MY_MAC_BYTE5;
189			packet.SenderMACAddr.v[5] = MY_MAC_BYTE6;
190
191			packet.SenderIPAddr.v[0] = MY_IP_BYTE1;
192			packet.SenderIPAddr.v[1] = MY_IP_BYTE2;
193			packet.SenderIPAddr.v[2] = MY_IP_BYTE3;
194			packet.SenderIPAddr.v[3] = MY_IP_BYTE4;
195
196
197			/*
198			* Check to see if target is on same subnet, if not, find
199			* Gateway MAC.
200			* Once we get Gateway MAC, all access to remote host will
201			* go through Gateway.
202			*/
203			if (((packet.SenderIPAddr.v[0] ^ remote->IPAddr.v[0]) &
204			MY_MASK_BYTE1) \|\|
205			((packet.SenderIPAddr.v[1] ^ remote->IPAddr.v[1]) &
206			MY_MASK_BYTE2) \|\|
207			((packet.SenderIPAddr.v[2] ^ remote->IPAddr.v[2]) &
208			MY_MASK_BYTE3) \|\|
209			((packet.SenderIPAddr.v[3] ^ remote->IPAddr.v[3]) &
210			MY_MASK_BYTE4) )
211			{
212			packet.TargetIPAddr.v[0] = MY_GATE_BYTE1;
213			packet.TargetIPAddr.v[1] = MY_GATE_BYTE2;
214			packet.TargetIPAddr.v[2] = MY_GATE_BYTE3;
215			packet.TargetIPAddr.v[3] = MY_GATE_BYTE4;
216			}
217			else
218			packet.TargetIPAddr = remote->IPAddr;
219
220			SwapARPPacket(&packet);
221
222			MACPutHeader(&packet.TargetMACAddr, MAC_ARP, sizeof(packet));
223
224			MACPutArray((BYTE*)&packet, sizeof(packet));
225
226			MACFlush();
227			}
228
229
230			/*********************************************************************
231			* Function: static void SwapARPPacket(ARP_PACKET* p)
232			*
233			* PreCondition: None
234			*
235			* Input: p - ARP packet to be swapped.
236			*
237			* Output: None
238			*
239			* Side Effects: None
240			*
241			* Overview: None
242			*
243			* Note: None
244			********************************************************************/
245			static void SwapARPPacket(ARP_PACKET *p)
246			{
247			p->HardwareType = swaps(p->HardwareType);
248			p->Protocol = swaps(p->Protocol);
249			p->Operation = swaps(p->Operation);
250			}