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	/*********************************************************************
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	}