PIC/Demo%20trimmet/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, PIC24F, PIC24H, dsPIC30F, dsPIC33F
 * Complier:        Microchip C18 v3.02 or higher
 *                                      Microchip C30 v2.01 or higher
 * Company:         Microchip Technology, Inc.
 *
 * Software License Agreement
 *
 * This software is owned by Microchip Technology Inc. ("Microchip") 
 * and is supplied to you for use exclusively as described in the 
 * associated software agreement.  This software is protected by 
 * software and other intellectual property laws.  Any use in 
 * violation of the software license may subject the user to criminal 
 * sanctions as well as civil liability.  Copyright 2006 Microchip
 * Technology Inc.  All rights reserved.
 *
 * This software is provided "AS IS."  MICROCHIP DISCLAIMS ALL 
 * WARRANTIES, EXPRESS, IMPLIED, STATUTORY OR OTHERWISE, NOT LIMITED 
 * TO MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND 
 * INFRINGEMENT.  Microchip shall in no event be liable for special, 
 * incidental, or consequential damages.
 *
 *
 * 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       0x01u
#define ARP_OPERATION_RESP      0x02u

// ETHERNET packet type as defined by IEEE 802.3
#define HW_ETHERNET             (0x0001u)
#define ARP_IP                  (0x0800u)


// 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;

// Helper function
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.Val == AppConfig.MyIPAddr.Val)
    {
        remote->MACAddr     = packet.SenderMACAddr;
        remote->IPAddr      = packet.SenderIPAddr;
        return TRUE;
    }
    else
        return FALSE;
}


/*********************************************************************
 * Function:        BOOL ARPPut(NODE_INFO* more, BYTE opCode)
 *
 * PreCondition:    None
 *
 * Input:           remote  - Remote node info
 *                  opCode  - ARP op code to send
 *
 * Output:          TRUE - The ARP packet was generated properly
 *                                      FALSE - Unable to allocate a TX buffer
 *
 * Side Effects:    None
 *
 * Overview:        None
 *
 * Note:            None
 ********************************************************************/
BOOL ARPPut(NODE_INFO *remote, BYTE opCode)
{
    ARP_PACKET packet;
        BUFFER MyTxBuffer = MACGetTxBuffer(TRUE);
        
        // Do not respond if there is no room to generate the ARP reply
        if(MyTxBuffer == INVALID_BUFFER)
                return FALSE;

        MACSetTxBuffer(MyTxBuffer, 0);
        

    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 = AppConfig.MyMACAddr;
    packet.SenderIPAddr  = AppConfig.MyIPAddr;

    // 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.Val ^ remote->IPAddr.Val) & AppConfig.MyMask.Val)
    {
                packet.TargetIPAddr = AppConfig.MyGateway;
    }
    else
        packet.TargetIPAddr = remote->IPAddr;

    SwapARPPacket(&packet);

    MACPutHeader(&packet.TargetMACAddr, MAC_ARP, sizeof(packet));
    MACPutArray((BYTE*)&packet, sizeof(packet));
    MACFlush();
        
        return TRUE;
}


/*********************************************************************
 * 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, PIC24F, PIC24H, dsPIC30F, dsPIC33F
13	* Complier: Microchip C18 v3.02 or higher
14	* Microchip C30 v2.01 or higher
15	* Company: Microchip Technology, Inc.
16	*
17	* Software License Agreement
18	*
19	* This software is owned by Microchip Technology Inc. ("Microchip")
20	* and is supplied to you for use exclusively as described in the
21	* associated software agreement. This software is protected by
22	* software and other intellectual property laws. Any use in
23	* violation of the software license may subject the user to criminal
24	* sanctions as well as civil liability. Copyright 2006 Microchip
25	* Technology Inc. All rights reserved.
26	*
27	* This software is provided "AS IS." MICROCHIP DISCLAIMS ALL
28	* WARRANTIES, EXPRESS, IMPLIED, STATUTORY OR OTHERWISE, NOT LIMITED
29	* TO MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
30	* INFRINGEMENT. Microchip shall in no event be liable for special,
31	* incidental, or consequential damages.
32	*
33	*
34	* Author Date Comment
35	*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
36	* Nilesh Rajbharti 5/1/01 Original (Rev 1.0)
37	* Nilesh Rajbharti 2/9/02 Cleanup
38	* Nilesh Rajbharti 5/22/02 Rev 2.0 (See version.log for detail)
39	********************************************************************/
40	#include <string.h>
41
42	#include "StackTsk.h"
43	#include "Helpers.h"
44	#include "ARP.h"
45	#include "MAC.h"
46
47	// ARP Operation codes.
48	#define ARP_OPERATION_REQ 0x01u
49	#define ARP_OPERATION_RESP 0x02u
50
51	// ETHERNET packet type as defined by IEEE 802.3
52	#define HW_ETHERNET (0x0001u)
53	#define ARP_IP (0x0800u)
54
55
56
57	// ARP packet
58	typedef struct _ARP_PACKET
59	{
60	WORD HardwareType;
61	WORD Protocol;
62	BYTE MACAddrLen;
63	BYTE ProtocolLen;
64	WORD Operation;
65	MAC_ADDR SenderMACAddr;
66	IP_ADDR SenderIPAddr;
67	MAC_ADDR TargetMACAddr;
68	IP_ADDR TargetIPAddr;
69	} ARP_PACKET;
70
71	// Helper function
72	static void SwapARPPacket(ARP_PACKET *p);
73
74
75
76	/*********************************************************************
77	* Function: BOOL ARPGet(NODE_INFO* remote, BYTE* opCode)
78	*
79	* PreCondition: ARP packet is ready in MAC buffer.
80	*
81	* Input: remote - Remote node info
82	* opCode - Buffer to hold ARP op code.
83	*
84	* Output: TRUE if a valid ARP packet was received.
85	* FALSE otherwise.
86	*
87	* Side Effects: None
88	*
89	* Overview: None
90	*
91	* Note: None
92	********************************************************************/
93	BOOL ARPGet(NODE_INFO remote, BYTE opCode)
94	{
95	ARP_PACKET packet;
96
97	MACGetArray((BYTE*)&packet, sizeof(packet));
98
99	MACDiscardRx();
100
101	SwapARPPacket(&packet);
102
103	if ( packet.HardwareType != HW_ETHERNET \|\|
104	packet.MACAddrLen != sizeof(MAC_ADDR) \|\|
105	packet.ProtocolLen != sizeof(IP_ADDR) )
106	{
107	return FALSE;
108	}
109
110	if ( packet.Operation == ARP_OPERATION_RESP )
111	{
112	*opCode = ARP_REPLY;
113	}
114	else if ( packet.Operation == ARP_OPERATION_REQ )
115	*opCode = ARP_REQUEST;
116	else
117	{
118	*opCode = ARP_UNKNOWN;
119	return FALSE;
120	}
121
122	if(packet.TargetIPAddr.Val == AppConfig.MyIPAddr.Val)
123	{
124	remote->MACAddr = packet.SenderMACAddr;
125	remote->IPAddr = packet.SenderIPAddr;
126	return TRUE;
127	}
128	else
129	return FALSE;
130	}
131
132
133	/*********************************************************************
134	* Function: BOOL ARPPut(NODE_INFO* more, BYTE opCode)
135	*
136	* PreCondition: None
137	*
138	* Input: remote - Remote node info
139	* opCode - ARP op code to send
140	*
141	* Output: TRUE - The ARP packet was generated properly
142	* FALSE - Unable to allocate a TX buffer
143	*
144	* Side Effects: None
145	*
146	* Overview: None
147	*
148	* Note: None
149	********************************************************************/
150	BOOL ARPPut(NODE_INFO *remote, BYTE opCode)
151	{
152	ARP_PACKET packet;
153	BUFFER MyTxBuffer = MACGetTxBuffer(TRUE);
154
155	// Do not respond if there is no room to generate the ARP reply
156	if(MyTxBuffer == INVALID_BUFFER)
157	return FALSE;
158
159	MACSetTxBuffer(MyTxBuffer, 0);
160
161
162	packet.HardwareType = HW_ETHERNET;
163	packet.Protocol = ARP_IP;
164	packet.MACAddrLen = sizeof(MAC_ADDR);
165	packet.ProtocolLen = sizeof(IP_ADDR);
166
167	if ( opCode == ARP_REQUEST )
168	{
169	packet.Operation = ARP_OPERATION_REQ;
170	packet.TargetMACAddr.v[0] = 0xff;
171	packet.TargetMACAddr.v[1] = 0xff;
172	packet.TargetMACAddr.v[2] = 0xff;
173	packet.TargetMACAddr.v[3] = 0xff;
174	packet.TargetMACAddr.v[4] = 0xff;
175	packet.TargetMACAddr.v[5] = 0xff;
176	}
177	else
178	{
179	packet.Operation = ARP_OPERATION_RESP;
180	packet.TargetMACAddr = remote->MACAddr;
181	}
182
183	packet.SenderMACAddr = AppConfig.MyMACAddr;
184	packet.SenderIPAddr = AppConfig.MyIPAddr;
185
186	// Check to see if target is on same subnet, if not, find Gateway MAC.
187	// Once we get Gateway MAC, all access to remote host will go through Gateway.
188	if((packet.SenderIPAddr.Val ^ remote->IPAddr.Val) & AppConfig.MyMask.Val)
189	{
190	packet.TargetIPAddr = AppConfig.MyGateway;
191	}
192	else
193	packet.TargetIPAddr = remote->IPAddr;
194
195	SwapARPPacket(&packet);
196
197	MACPutHeader(&packet.TargetMACAddr, MAC_ARP, sizeof(packet));
198	MACPutArray((BYTE*)&packet, sizeof(packet));
199	MACFlush();
200
201	return TRUE;
202	}
203
204
205	/*********************************************************************
206	* Function: static void SwapARPPacket(ARP_PACKET* p)
207	*
208	* PreCondition: None
209	*
210	* Input: p - ARP packet to be swapped.
211	*
212	* Output: None
213	*
214	* Side Effects: None
215	*
216	* Overview: None
217	*
218	* Note: None
219	********************************************************************/
220	static void SwapARPPacket(ARP_PACKET *p)
221	{
222	p->HardwareType = swaps(p->HardwareType);
223	p->Protocol = swaps(p->Protocol);
224	p->Operation = swaps(p->Operation);
225	}