Microchip%20TCP_IP%20stack/TCPIP%20Stack/IP.c

/*********************************************************************
 *
 *  Internet Protocol (IP) Version 4 Communications Layer
 *  Module for Microchip TCP/IP Stack
 *   -Provides a transport for TCP, UDP, and ICMP messages
 *       -Reference: RFC 791
 *
 *********************************************************************
 * FileName:        IP.C
 * Dependencies:    string.h
 *                  StackTsk.h
 *                  Helpers.h
 *                  IP.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
 *
 * Copyright © 2002-2007 Microchip Technology Inc.  All rights 
 * reserved.
 *
 * Microchip licenses to you the right to use, modify, copy, and 
 * distribute: 
 * (i)  the Software when embedded on a Microchip microcontroller or 
 *      digital signal controller product (“Device”) which is 
 *      integrated into Licensee’s product; or
 * (ii) ONLY the Software driver source files ENC28J60.c and 
 *      ENC28J60.h ported to a non-Microchip device used in 
 *      conjunction with a Microchip ethernet controller for the 
 *      sole purpose of interfacing with the ethernet controller. 
 *
 * You should refer to the license agreement accompanying this 
 * Software for additional information regarding your rights and 
 * obligations.
 *
 * THE SOFTWARE AND DOCUMENTATION ARE PROVIDED “AS IS” WITHOUT 
 * WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT 
 * LIMITATION, ANY WARRANTY OF MERCHANTABILITY, FITNESS FOR A 
 * PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL 
 * MICROCHIP BE LIABLE FOR ANY INCIDENTAL, SPECIAL, INDIRECT OR 
 * CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF 
 * PROCUREMENT OF SUBSTITUTE GOODS, TECHNOLOGY OR SERVICES, ANY CLAIMS 
 * BY THIRD PARTIES (INCLUDING BUT NOT LIMITED TO ANY DEFENSE 
 * THEREOF), ANY CLAIMS FOR INDEMNITY OR CONTRIBUTION, OR OTHER 
 * SIMILAR COSTS, WHETHER ASSERTED ON THE BASIS OF CONTRACT, TORT 
 * (INCLUDING NEGLIGENCE), BREACH OF WARRANTY, OR OTHERWISE.
 *
 *
 * Author               Date    Comment
 *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 * Nilesh Rajbharti     4/27/01 Original        (Rev 1.0)
 * Nilesh Rajbharti     2/9/02  Cleanup
 * Nilesh Rajbharti     5/22/02 Rev 2.0 (See version.log for detail)
 * Howard Schlunder             8/31/04 Beta Rev 0.9 (See version.log for detail)
 * Howard Schlunder             1/5/06  Improved DMA checksum efficiency
 * Darren Rook                  9/21/06 Corrected IPHeaderLen not being 
 *                                                              initialized when NON_MCHP_MAC defined.
 ********************************************************************/
#define __IP_C

#include "TCPIP Stack/TCPIP.h"

// This is left shifted by 4.  Actual value is 0x04.
#define IPv4                (0x40u)
#define IP_VERSION          IPv4

// IHL (Internet Header Length) is # of DWORDs in a header.
// Since, we do not support options, our IP header length will be
// minimum i.e. 20 bytes : IHL = 20 / 4 = 5.
#define IP_IHL              (0x05)

#define IP_SERVICE_NW_CTRL  (0x07)
#define IP_SERVICE_IN_CTRL  (0x06)
#define IP_SERVICE_ECP      (0x05)
#define IP_SERVICE_OVR      (0x04)
#define IP_SERVICE_FLASH    (0x03)
#define IP_SERVICE_IMM      (0x02)
#define IP_SERVICE_PRIOR    (0x01)
#define IP_SERVICE_ROUTINE  (0x00)

#define IP_SERVICE_N_DELAY  (0x00)
#define IP_SERCICE_L_DELAY  (0x08)
#define IP_SERVICE_N_THRPT  (0x00)
#define IP_SERVICE_H_THRPT  (0x10)
#define IP_SERVICE_N_RELIB  (0x00)
#define IP_SERVICE_H_RELIB  (0x20)

#define IP_SERVICE          (IP_SERVICE_ROUTINE | IP_SERVICE_N_DELAY)

#define MY_IP_TTL           (100)  // Time-To-Live in hops


static WORD _Identifier = 0;
static BYTE IPHeaderLen;


static void SwapIPHeader(IP_HEADER* h);


/*********************************************************************
 * Function:        BOOL IPGetHeader( IP_ADDR    *localIP,
 *                                    NODE_INFO  *remote,
 *                                    BYTE        *Protocol,
 *                                    WORD        *len)
 *
 * PreCondition:    MACGetHeader() == TRUE
 *
 * Input:           localIP     - Local node IP Address as received
 *                                in current IP header.
 *                                If this information is not required
 *                                caller may pass NULL value.
 *                  remote      - Remote node info
 *                  Protocol    - Current packet protocol
 *                  len         - Current packet data length
 *
 * Output:          TRUE, if valid packet was received
 *                  FALSE otherwise
 *
 * Side Effects:    None
 *
 * Note:            Only one IP message can be received.
 *                  Caller may not transmit and receive a message
 *                  at the same time.
 *
 ********************************************************************/
BOOL IPGetHeader(IP_ADDR *localIP,
                 NODE_INFO *remote,
                 BYTE *protocol,
                 WORD *len)
{
    WORD_VAL    CalcChecksum;
    IP_HEADER   header;

#if defined(NON_MCHP_MAC)
    WORD_VAL    ReceivedChecksum;
    WORD        checksums[2];
    BYTE        optionsLen;
        #define MAX_OPTIONS_LEN     (40)            // As per RFC 791.
    BYTE        options[MAX_OPTIONS_LEN];
#endif

    // Read IP header.
    MACGetArray((BYTE*)&header, sizeof(header));

    // Make sure that this is an IPv4 packet.
    if ( (header.VersionIHL & 0xf0) != IP_VERSION )
        return FALSE;

        IPHeaderLen = (header.VersionIHL & 0x0f) << 2;

#if !defined(NON_MCHP_MAC)
        // Validate the IP header.  If it is correct, the checksum 
        // will come out to 0x0000 (because the header contains a 
        // precomputed checksum).  A corrupt header will have a 
        // nonzero checksum.
        CalcChecksum.Val = MACCalcRxChecksum(0, IPHeaderLen);

        // Seek to the end of the IP header
        MACSetReadPtrInRx(IPHeaderLen);

    if(CalcChecksum.Val)
#else
    // Calculate options length in this header, if there is any.
    // IHL is in terms of numbers of 32-bit DWORDs; i.e. actual
    // length is 4 times IHL.
    optionsLen = IPHeaderLen - sizeof(header);

    // If there is any option(s), read it so that we can include them
    // in checksum calculation.
    if ( optionsLen > MAX_OPTIONS_LEN )
        return FALSE;

    if ( optionsLen > 0 )
        MACGetArray(options, optionsLen);

    // Save header checksum; clear it and recalculate it ourselves.
    ReceivedChecksum.Val = header.HeaderChecksum;
    header.HeaderChecksum = 0;

    // Calculate checksum of header including options bytes.
    checksums[0] = ~CalcIPChecksum((BYTE*)&header, sizeof(header));

    // Calculate Options checksum too, if they are present.
    if ( optionsLen > 0 )
        checksums[1] = ~CalcIPChecksum((BYTE*)options, optionsLen);
    else
        checksums[1] = 0;

    CalcChecksum.Val  = CalcIPChecksum((BYTE*)checksums,
                                            2 * sizeof(WORD));

    // Make sure that checksum is correct
    if ( ReceivedChecksum.Val != CalcChecksum.Val )
#endif
    {
        // Bad packet. The function caller will be notified by means of the FALSE 
        // return value and it should discard the packet.
        return FALSE;
    }

    // Network to host conversion.
    SwapIPHeader(&header);

    // If caller is intrested, return destination IP address
    // as seen in this IP header.
    if ( localIP )
        localIP->Val    = header.DestAddress.Val;

    remote->IPAddr.Val  = header.SourceAddress.Val;
    *protocol           = header.Protocol;
    *len                                = header.TotalLength - IPHeaderLen;

    return TRUE;
}


/*********************************************************************
 * Function: WORD IPPutHeader(NODE_INFO *remote,
 *                                        BYTE protocol,
 *                                        WORD len)
 *
 * PreCondition:    IPIsTxReady() == TRUE
 *
 * Input:           *remote     - Destination node address
 *                  protocol    - Current packet protocol
 *                  len         - Current packet data length
 *
 * Output:          (WORD)0
 *
 * Side Effects:    None
 *
 * Note:            Only one IP message can be transmitted at any
 *                  time.
 ********************************************************************/
WORD IPPutHeader(NODE_INFO *remote,
                 BYTE protocol,
                 WORD len)
{
    IP_HEADER   header;
    
    IPHeaderLen = sizeof(IP_HEADER);

    header.VersionIHL       = IP_VERSION | IP_IHL;
    header.TypeOfService    = IP_SERVICE;
    header.TotalLength      = sizeof(header) + len;
    header.Identification   = ++_Identifier;
    header.FragmentInfo     = 0;
    header.TimeToLive       = MY_IP_TTL;
    header.Protocol         = protocol;
    header.HeaderChecksum   = 0;
        header.SourceAddress    = AppConfig.MyIPAddr;

    header.DestAddress.Val = remote->IPAddr.Val;

    SwapIPHeader(&header);

    header.HeaderChecksum   = CalcIPChecksum((BYTE*)&header, sizeof(header));

    MACPutHeader(&remote->MACAddr, MAC_IP, (sizeof(header)+len));
    MACPutArray((BYTE*)&header, sizeof(header));

    return 0x0000;

}

/*********************************************************************
 * Function:        IPSetRxBuffer(WORD Offset)
 *
 * PreCondition:    IPHeaderLen must have been intialized by 
 *                                      IPGetHeader() or IPPutHeader()
 *
 * Input:           Offset from beginning of IP data field
 *
 * Output:          Next Read/Write access to receive buffer is
 *                  set to Offset 
 *
 * Side Effects:    None
 *
 * Note:            None
 *
 ********************************************************************/
void IPSetRxBuffer(WORD Offset) 
{
        MACSetReadPtrInRx(Offset+IPHeaderLen);
}


static void SwapIPHeader(IP_HEADER* h)
{
    h->TotalLength      = swaps(h->TotalLength);
    h->Identification   = swaps(h->Identification);
    h->HeaderChecksum   = swaps(h->HeaderChecksum);
}
1	/*********************************************************************
2	*
3	* Internet Protocol (IP) Version 4 Communications Layer
4	* Module for Microchip TCP/IP Stack
5	* -Provides a transport for TCP, UDP, and ICMP messages
6	* -Reference: RFC 791
7	*
8	*********************************************************************
9	* FileName: IP.C
10	* Dependencies: string.h
11	* StackTsk.h
12	* Helpers.h
13	* IP.h
14	* Processor: PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F
15	* Complier: Microchip C18 v3.02 or higher
16	* Microchip C30 v2.01 or higher
17	* Company: Microchip Technology, Inc.
18	*
19	* Software License Agreement
20	*
21	* Copyright © 2002-2007 Microchip Technology Inc. All rights
22	* reserved.
23	*
24	* Microchip licenses to you the right to use, modify, copy, and
25	* distribute:
26	* (i) the Software when embedded on a Microchip microcontroller or
27	* digital signal controller product (“Device”) which is
28	* integrated into Licensee’s product; or
29	* (ii) ONLY the Software driver source files ENC28J60.c and
30	* ENC28J60.h ported to a non-Microchip device used in
31	* conjunction with a Microchip ethernet controller for the
32	* sole purpose of interfacing with the ethernet controller.
33	*
34	* You should refer to the license agreement accompanying this
35	* Software for additional information regarding your rights and
36	* obligations.
37	*
38	* THE SOFTWARE AND DOCUMENTATION ARE PROVIDED “AS IS” WITHOUT
39	* WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT
40	* LIMITATION, ANY WARRANTY OF MERCHANTABILITY, FITNESS FOR A
41	* PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL
42	* MICROCHIP BE LIABLE FOR ANY INCIDENTAL, SPECIAL, INDIRECT OR
43	* CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF
44	* PROCUREMENT OF SUBSTITUTE GOODS, TECHNOLOGY OR SERVICES, ANY CLAIMS
45	* BY THIRD PARTIES (INCLUDING BUT NOT LIMITED TO ANY DEFENSE
46	* THEREOF), ANY CLAIMS FOR INDEMNITY OR CONTRIBUTION, OR OTHER
47	* SIMILAR COSTS, WHETHER ASSERTED ON THE BASIS OF CONTRACT, TORT
48	* (INCLUDING NEGLIGENCE), BREACH OF WARRANTY, OR OTHERWISE.
49	*
50	*
51	* Author Date Comment
52	*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
53	* Nilesh Rajbharti 4/27/01 Original (Rev 1.0)
54	* Nilesh Rajbharti 2/9/02 Cleanup
55	* Nilesh Rajbharti 5/22/02 Rev 2.0 (See version.log for detail)
56	* Howard Schlunder 8/31/04 Beta Rev 0.9 (See version.log for detail)
57	* Howard Schlunder 1/5/06 Improved DMA checksum efficiency
58	* Darren Rook 9/21/06 Corrected IPHeaderLen not being
59	* initialized when NON_MCHP_MAC defined.
60	********************************************************************/
61	#define __IP_C
62
63	#include "TCPIP Stack/TCPIP.h"
64
65	// This is left shifted by 4. Actual value is 0x04.
66	#define IPv4 (0x40u)
67	#define IP_VERSION IPv4
68
69	// IHL (Internet Header Length) is # of DWORDs in a header.
70	// Since, we do not support options, our IP header length will be
71	// minimum i.e. 20 bytes : IHL = 20 / 4 = 5.
72	#define IP_IHL (0x05)
73
74	#define IP_SERVICE_NW_CTRL (0x07)
75	#define IP_SERVICE_IN_CTRL (0x06)
76	#define IP_SERVICE_ECP (0x05)
77	#define IP_SERVICE_OVR (0x04)
78	#define IP_SERVICE_FLASH (0x03)
79	#define IP_SERVICE_IMM (0x02)
80	#define IP_SERVICE_PRIOR (0x01)
81	#define IP_SERVICE_ROUTINE (0x00)
82
83	#define IP_SERVICE_N_DELAY (0x00)
84	#define IP_SERCICE_L_DELAY (0x08)
85	#define IP_SERVICE_N_THRPT (0x00)
86	#define IP_SERVICE_H_THRPT (0x10)
87	#define IP_SERVICE_N_RELIB (0x00)
88	#define IP_SERVICE_H_RELIB (0x20)
89
90	#define IP_SERVICE (IP_SERVICE_ROUTINE \| IP_SERVICE_N_DELAY)
91
92	#define MY_IP_TTL (100) // Time-To-Live in hops
93
94
95
96
97	static WORD _Identifier = 0;
98	static BYTE IPHeaderLen;
99
100
101	static void SwapIPHeader(IP_HEADER* h);
102
103
104
105
106	/*********************************************************************
107	* Function: BOOL IPGetHeader( IP_ADDR *localIP,
108	* NODE_INFO *remote,
109	* BYTE *Protocol,
110	* WORD *len)
111	*
112	* PreCondition: MACGetHeader() == TRUE
113	*
114	* Input: localIP - Local node IP Address as received
115	* in current IP header.
116	* If this information is not required
117	* caller may pass NULL value.
118	* remote - Remote node info
119	* Protocol - Current packet protocol
120	* len - Current packet data length
121	*
122	* Output: TRUE, if valid packet was received
123	* FALSE otherwise
124	*
125	* Side Effects: None
126	*
127	* Note: Only one IP message can be received.
128	* Caller may not transmit and receive a message
129	* at the same time.
130	*
131	********************************************************************/
132	BOOL IPGetHeader(IP_ADDR *localIP,
133	NODE_INFO *remote,
134	BYTE *protocol,
135	WORD *len)
136	{
137	WORD_VAL CalcChecksum;
138	IP_HEADER header;
139
140	#if defined(NON_MCHP_MAC)
141	WORD_VAL ReceivedChecksum;
142	WORD checksums[2];
143	BYTE optionsLen;
144	#define MAX_OPTIONS_LEN (40) // As per RFC 791.
145	BYTE options[MAX_OPTIONS_LEN];
146	#endif
147
148	// Read IP header.
149	MACGetArray((BYTE*)&header, sizeof(header));
150
151	// Make sure that this is an IPv4 packet.
152	if ( (header.VersionIHL & 0xf0) != IP_VERSION )
153	return FALSE;
154
155	IPHeaderLen = (header.VersionIHL & 0x0f) << 2;
156
157	#if !defined(NON_MCHP_MAC)
158	// Validate the IP header. If it is correct, the checksum
159	// will come out to 0x0000 (because the header contains a
160	// precomputed checksum). A corrupt header will have a
161	// nonzero checksum.
162	CalcChecksum.Val = MACCalcRxChecksum(0, IPHeaderLen);
163
164	// Seek to the end of the IP header
165	MACSetReadPtrInRx(IPHeaderLen);
166
167	if(CalcChecksum.Val)
168	#else
169	// Calculate options length in this header, if there is any.
170	// IHL is in terms of numbers of 32-bit DWORDs; i.e. actual
171	// length is 4 times IHL.
172	optionsLen = IPHeaderLen - sizeof(header);
173
174	// If there is any option(s), read it so that we can include them
175	// in checksum calculation.
176	if ( optionsLen > MAX_OPTIONS_LEN )
177	return FALSE;
178
179	if ( optionsLen > 0 )
180	MACGetArray(options, optionsLen);
181
182	// Save header checksum; clear it and recalculate it ourselves.
183	ReceivedChecksum.Val = header.HeaderChecksum;
184	header.HeaderChecksum = 0;
185
186	// Calculate checksum of header including options bytes.
187	checksums[0] = ~CalcIPChecksum((BYTE*)&header, sizeof(header));
188
189	// Calculate Options checksum too, if they are present.
190	if ( optionsLen > 0 )
191	checksums[1] = ~CalcIPChecksum((BYTE*)options, optionsLen);
192	else
193	checksums[1] = 0;
194
195	CalcChecksum.Val = CalcIPChecksum((BYTE*)checksums,
196	2 * sizeof(WORD));
197
198	// Make sure that checksum is correct
199	if ( ReceivedChecksum.Val != CalcChecksum.Val )
200	#endif
201	{
202	// Bad packet. The function caller will be notified by means of the FALSE
203	// return value and it should discard the packet.
204	return FALSE;
205	}
206
207	// Network to host conversion.
208	SwapIPHeader(&header);
209
210	// If caller is intrested, return destination IP address
211	// as seen in this IP header.
212	if ( localIP )
213	localIP->Val = header.DestAddress.Val;
214
215	remote->IPAddr.Val = header.SourceAddress.Val;
216	*protocol = header.Protocol;
217	*len = header.TotalLength - IPHeaderLen;
218
219	return TRUE;
220	}
221
222
223
224
225	/*********************************************************************
226	* Function: WORD IPPutHeader(NODE_INFO *remote,
227	* BYTE protocol,
228	* WORD len)
229	*
230	* PreCondition: IPIsTxReady() == TRUE
231	*
232	* Input: *remote - Destination node address
233	* protocol - Current packet protocol
234	* len - Current packet data length
235	*
236	* Output: (WORD)0
237	*
238	* Side Effects: None
239	*
240	* Note: Only one IP message can be transmitted at any
241	* time.
242	********************************************************************/
243	WORD IPPutHeader(NODE_INFO *remote,
244	BYTE protocol,
245	WORD len)
246	{
247	IP_HEADER header;
248
249	IPHeaderLen = sizeof(IP_HEADER);
250
251	header.VersionIHL = IP_VERSION \| IP_IHL;
252	header.TypeOfService = IP_SERVICE;
253	header.TotalLength = sizeof(header) + len;
254	header.Identification = ++_Identifier;
255	header.FragmentInfo = 0;
256	header.TimeToLive = MY_IP_TTL;
257	header.Protocol = protocol;
258	header.HeaderChecksum = 0;
259	header.SourceAddress = AppConfig.MyIPAddr;
260
261	header.DestAddress.Val = remote->IPAddr.Val;
262
263	SwapIPHeader(&header);
264
265	header.HeaderChecksum = CalcIPChecksum((BYTE*)&header, sizeof(header));
266
267	MACPutHeader(&remote->MACAddr, MAC_IP, (sizeof(header)+len));
268	MACPutArray((BYTE*)&header, sizeof(header));
269
270	return 0x0000;
271
272	}
273
274	/*********************************************************************
275	* Function: IPSetRxBuffer(WORD Offset)
276	*
277	* PreCondition: IPHeaderLen must have been intialized by
278	* IPGetHeader() or IPPutHeader()
279	*
280	* Input: Offset from beginning of IP data field
281	*
282	* Output: Next Read/Write access to receive buffer is
283	* set to Offset
284	*
285	* Side Effects: None
286	*
287	* Note: None
288	*
289	********************************************************************/
290	void IPSetRxBuffer(WORD Offset)
291	{
292	MACSetReadPtrInRx(Offset+IPHeaderLen);
293	}
294
295
296
297	static void SwapIPHeader(IP_HEADER* h)
298	{
299	h->TotalLength = swaps(h->TotalLength);
300	h->Identification = swaps(h->Identification);
301	h->HeaderChecksum = swaps(h->HeaderChecksum);
302	}