PIC/TCP-IP%20stack/ip.c

/*********************************************************************
 *
 *                  PIC IP Module for Microchip TCP/IP Stack
 *
 *********************************************************************
 * FileName:        IP.C
 * Dependencies:    string.h
 *                  StackTsk.h
 *                  Helpers.h
 *                  IP.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 -O -Zg -E -C
 *
 *
 *
 *
 * 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)
 ********************************************************************/

#include <string.h>

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

// This is left shifted by 4.  Actual value is 0x04.
#define IPv4                (0x40)
#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 Seconds */


static WORD _Identifier = 0;


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    ReceivedChecksum;
    WORD_VAL    CalcChecksum;
    WORD        checksums[2];
    IP_HEADER   header;
    BYTE        optionsLen;
#define MAX_OPTIONS_LEN     (20)            // As per RFC 791.
    BYTE        options[MAX_OPTIONS_LEN];

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

    // Make sure that this IPv4 packet.
    if ( (header.VersionIHL & 0xf0) != IP_VERSION )
    {
        goto IPGetHeader_Discard;
    }

    /*
     * 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 = ((header.VersionIHL & 0x0f) << 2) - sizeof(header);

    /*
     * If there is any option(s), read it so that we can include them
     * in checksum calculation.
     */
    if ( optionsLen > MAX_OPTIONS_LEN )
    {
        goto IPGetHeader_Discard;
    }

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

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

    // Make sure that checksum is correct and IP version is supported.
    if ( ReceivedChecksum.Val != CalcChecksum.Val   ||
         (header.VersionIHL & 0xf0) != IP_VERSION )

    {
        // Bad/Unknown packet. Discard it.
        goto IPGetHeader_Discard;
    }

    /*
     * 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 - optionsLen -
                            sizeof(header);

    return TRUE;

IPGetHeader_Discard:
    MACDiscardRx();
    return FALSE;

}


/*********************************************************************
 * Function:        WORD IPPutHeader(   IP_ADDR *Dest,
 *                                      BYTE    Protocol,
 *                                      WORD    Identifier,
 *                                      WORD    DataLen)
 *
 * PreCondition:    IPIsTxReady() == TRUE
 *
 * Input:           Src         - Destination node address
 *                  Protocol    - Current packet protocol
 *                  Identifier  - Current packet identifier
 *                  DataLen     - Current packet data length
 *
 * Output:          Handle to current packet - For use by
 *                  IPSendByte() function.
 *
 * Side Effects:    None
 *
 * Note:            Only one IP message can be transmitted at any
 *                  time.
 *                  Caller may not transmit and receive a message
 *                  at the same time.
 *
 ********************************************************************/
WORD IPPutHeader(NODE_INFO *remote,
                BYTE protocol,
                WORD    len)
{
    IP_HEADER   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.v[0] = MY_IP_BYTE1;
    header.SourceAddress.v[1] = MY_IP_BYTE2;
    header.SourceAddress.v[2] = MY_IP_BYTE3;
    header.SourceAddress.v[3] = MY_IP_BYTE4;

    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 0x0;

}


static void SwapIPHeader(IP_HEADER* h)
{
    h->TotalLength      = swaps(h->TotalLength);
    h->Identification   = swaps(h->Identification);
    h->HeaderChecksum   = swaps(h->HeaderChecksum);
}
1	/*********************************************************************
2	*
3	* PIC IP Module for Microchip TCP/IP Stack
4	*
5	*********************************************************************
6	* FileName: IP.C
7	* Dependencies: string.h
8	* StackTsk.h
9	* Helpers.h
10	* IP.h
11	* Processor: PIC18
12	* Complier: MCC18 v1.00.50 or higher
13	* HITECH PICC-18 V8.10PL1 or higher
14	* Company: Microchip Technology, Inc.
15	*
16	* Software License Agreement
17	*
18	* The software supplied herewith by Microchip Technology Incorporated
19	* (the “Company”) for its PICmicro® Microcontroller is intended and
20	* supplied to you, the Company’s customer, for use solely and
21	* exclusively on Microchip PICmicro Microcontroller products. The
22	* software is owned by the Company and/or its supplier, and is
23	* protected under applicable copyright laws. All rights are reserved.
24	* Any use in violation of the foregoing restrictions may subject the
25	* user to criminal sanctions under applicable laws, as well as to
26	* civil liability for the breach of the terms and conditions of this
27	* license.
28	*
29	* THIS SOFTWARE IS PROVIDED IN AN “AS IS” CONDITION. NO WARRANTIES,
30	* WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT NOT LIMITED
31	* TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
32	* PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. THE COMPANY SHALL NOT,
33	* IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL OR
34	* CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER.
35	*
36	* HiTech PICC18 Compiler Options excluding device selection:
37	* -FAKELOCAL -G -O -Zg -E -C
38	*
39	*
40	*
41	*
42	* Author Date Comment
43	*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
44	* Nilesh Rajbharti 4/27/01 Original (Rev 1.0)
45	* Nilesh Rajbharti 2/9/02 Cleanup
46	* Nilesh Rajbharti 5/22/02 Rev 2.0 (See version.log for detail)
47	********************************************************************/
48
49	#include <string.h>
50
51	#include "stacktsk.h"
52	#include "helpers.h"
53	#include "mac.h"
54	#include "ip.h"
55
56	// This is left shifted by 4. Actual value is 0x04.
57	#define IPv4 (0x40)
58	#define IP_VERSION IPv4
59
60	/*
61	* IHL (Internet Header Length) is # of DWORDs in a header.
62	* Since, we do not support options, our IP header length will be
63	* minimum i.e. 20 bytes : IHL = 20 / 4 = 5.
64	*/
65	#define IP_IHL (0x05)
66
67	#define IP_SERVICE_NW_CTRL (0x07)
68	#define IP_SERVICE_IN_CTRL (0x06)
69	#define IP_SERVICE_ECP (0x05)
70	#define IP_SERVICE_OVR (0x04)
71	#define IP_SERVICE_FLASH (0x03)
72	#define IP_SERVICE_IMM (0x02)
73	#define IP_SERVICE_PRIOR (0x01)
74	#define IP_SERVICE_ROUTINE (0x00)
75
76	#define IP_SERVICE_N_DELAY (0x00)
77	#define IP_SERCICE_L_DELAY (0x08)
78	#define IP_SERVICE_N_THRPT (0x00)
79	#define IP_SERVICE_H_THRPT (0x10)
80	#define IP_SERVICE_N_RELIB (0x00)
81	#define IP_SERVICE_H_RELIB (0x20)
82
83	#define IP_SERVICE (IP_SERVICE_ROUTINE \| IP_SERVICE_N_DELAY)
84
85	#define MY_IP_TTL (100) /* Time-To-Live in Seconds */
86
87
88
89
90	static WORD _Identifier = 0;
91
92
93	static void SwapIPHeader(IP_HEADER* h);
94
95
96
97
98	/*********************************************************************
99	* Function: BOOL IPGetHeader( IP_ADDR *localIP,
100	* NODE_INFO *remote,
101	* BYTE *Protocol,
102	* WORD *len)
103	*
104	* PreCondition: MACGetHeader() == TRUE
105	*
106	* Input: localIP - Local node IP Address as received
107	* in current IP header.
108	* If this information is not required
109	* caller may pass NULL value.
110	* remote - Remote node info
111	* Protocol - Current packet protocol
112	* len - Current packet data length
113	*
114	* Output: TRUE, if valid packet was received
115	* FALSE otherwise
116	*
117	* Side Effects: None
118	*
119	* Note: Only one IP message can be received.
120	* Caller may not transmit and receive a message
121	* at the same time.
122	*
123	********************************************************************/
124	BOOL IPGetHeader(IP_ADDR *localIP,
125	NODE_INFO *remote,
126	BYTE *protocol,
127	WORD *len)
128	{
129	WORD_VAL ReceivedChecksum;
130	WORD_VAL CalcChecksum;
131	WORD checksums[2];
132	IP_HEADER header;
133	BYTE optionsLen;
134	#define MAX_OPTIONS_LEN (20) // As per RFC 791.
135	BYTE options[MAX_OPTIONS_LEN];
136
137	// Read IP header.
138	MACGetArray((BYTE*)&header, sizeof(header));
139
140	// Make sure that this IPv4 packet.
141	if ( (header.VersionIHL & 0xf0) != IP_VERSION )
142	{
143	goto IPGetHeader_Discard;
144	}
145
146	/*
147	* Calculate options length in this header, if there is any.
148	* IHL is in terms of numbers of 32-bit DWORDs; i.e. actual
149	* length is 4 times IHL.
150	*/
151	optionsLen = ((header.VersionIHL & 0x0f) << 2) - sizeof(header);
152
153	/*
154	* If there is any option(s), read it so that we can include them
155	* in checksum calculation.
156	*/
157	if ( optionsLen > MAX_OPTIONS_LEN )
158	{
159	goto IPGetHeader_Discard;
160	}
161
162	if ( optionsLen > 0 )
163	MACGetArray(options, optionsLen);
164
165	// Save header checksum; clear it and recalculate it ourselves.
166	ReceivedChecksum.Val = header.HeaderChecksum;
167	header.HeaderChecksum = 0;
168
169	// Calculate checksum of header including options bytes.
170	checksums[0] = ~CalcIPChecksum((BYTE*)&header, sizeof(header));
171
172	// Calculate Options checksum too, if they are present.
173	if ( optionsLen > 0 )
174	checksums[1] = ~CalcIPChecksum((BYTE*)options, optionsLen);
175	else
176	checksums[1] = 0;
177
178	CalcChecksum.Val = CalcIPChecksum((BYTE*)checksums,
179	2 * sizeof(WORD));
180
181	// Network to host conversion.
182	SwapIPHeader(&header);
183
184	// Make sure that checksum is correct and IP version is supported.
185	if ( ReceivedChecksum.Val != CalcChecksum.Val \|\|
186	(header.VersionIHL & 0xf0) != IP_VERSION )
187
188	{
189	// Bad/Unknown packet. Discard it.
190	goto IPGetHeader_Discard;
191	}
192
193	/*
194	* If caller is intrested, return destination IP address
195	* as seen in this IP header.
196	*/
197	if ( localIP )
198	localIP->Val = header.DestAddress.Val;
199
200	remote->IPAddr.Val = header.SourceAddress.Val;
201	*protocol = header.Protocol;
202	*len = header.TotalLength - optionsLen -
203	sizeof(header);
204
205	return TRUE;
206
207	IPGetHeader_Discard:
208	MACDiscardRx();
209	return FALSE;
210
211	}
212
213
214
215
216	/*********************************************************************
217	* Function: WORD IPPutHeader( IP_ADDR *Dest,
218	* BYTE Protocol,
219	* WORD Identifier,
220	* WORD DataLen)
221	*
222	* PreCondition: IPIsTxReady() == TRUE
223	*
224	* Input: Src - Destination node address
225	* Protocol - Current packet protocol
226	* Identifier - Current packet identifier
227	* DataLen - Current packet data length
228	*
229	* Output: Handle to current packet - For use by
230	* IPSendByte() function.
231	*
232	* Side Effects: None
233	*
234	* Note: Only one IP message can be transmitted at any
235	* time.
236	* Caller may not transmit and receive a message
237	* at the same time.
238	*
239	********************************************************************/
240	WORD IPPutHeader(NODE_INFO *remote,
241	BYTE protocol,
242	WORD len)
243	{
244	IP_HEADER header;
245
246	header.VersionIHL = IP_VERSION \| IP_IHL;
247	header.TypeOfService = IP_SERVICE;
248	header.TotalLength = sizeof(header) + len;
249	header.Identification = ++_Identifier;
250	header.FragmentInfo = 0;
251	header.TimeToLive = MY_IP_TTL;
252	header.Protocol = protocol;
253	header.HeaderChecksum = 0;
254	header.SourceAddress.v[0] = MY_IP_BYTE1;
255	header.SourceAddress.v[1] = MY_IP_BYTE2;
256	header.SourceAddress.v[2] = MY_IP_BYTE3;
257	header.SourceAddress.v[3] = MY_IP_BYTE4;
258
259	header.DestAddress.Val = remote->IPAddr.Val;
260
261	SwapIPHeader(&header);
262
263	header.HeaderChecksum = CalcIPChecksum((BYTE*)&header,
264	sizeof(header));
265
266	MACPutHeader(&remote->MACAddr, MAC_IP, (sizeof(header)+len));
267	MACPutArray((BYTE*)&header, sizeof(header));
268
269	return 0x0;
270
271	}
272
273
274	static void SwapIPHeader(IP_HEADER* h)
275	{
276	h->TotalLength = swaps(h->TotalLength);
277	h->Identification = swaps(h->Identification);
278	h->HeaderChecksum = swaps(h->HeaderChecksum);
279	}