src/rohc/c_uncompressed.c

/*
    ROHC Project 2003 at Lulea University of Technology, Sweden.
    Authors: Andreas Vernersson <andver-8@student.luth.se>
             Daniel Pettersson <danpet-7@student.luth.se>
             Erik Soderstrom <soderstrom@yahoo.com>
             Fredrik Lindstrom <frelin-9@student.luth.se>
             Johan Stenmark <johste-8@student.luth.se>
             Martin Juhlin <juhlin@users.sourceforge.net>
             Mikael Larsson <larmik-9@student.luth.se>
             Robert Maxe <robmax-1@student.luth.se>
             
    Copyright (C) 2003 Andreas Vernersson, Daniel Pettersson, 
    Erik Soderström, Fredrik Lindström, Johan Stenmark, 
    Martin Juhlin, Mikael Larsson, Robert Maxe.  

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/    
/*
 * Implementation of the uncompressed profile (compressor)
 */
 
#include <linux/ip.h>

#include "rohc.h"
#include "comp.h"
#include "c_util.h"


/*
Structure that contain counters, flags and structures that need to saved between different
packages. Every context have one of these
*/
struct sc_uncompressed_context {
        int ir_count, normal_count;
        int go_back_ir_count;


};

static void uncompressed_decide_state(struct sc_context *context);

static void uncompressed_periodic_down_transition(struct sc_context *context);

static void uncompressed_change_mode(struct sc_context *c, C_MODE new_mode);

static void uncompressed_change_state(struct sc_context *c, C_STATE new_state);

static int uncompressed_code_packet(struct sc_context *context,
        const struct iphdr *ip,
        unsigned char *dest,
        int *payload_offset,
        int max_size);

static int uncompressed_code_IR_packet(struct sc_context *context,
        const struct iphdr *ip,
        unsigned char *dest,
        int *payload_offset,
        int max_size);

static int uncompressed_code_normal_packet(struct sc_context *context,
        const struct iphdr *ip,
        unsigned char *dest,
        int *payload_offset,
        int max_size);

/*
Function to allocate for a new context, it aslo initilize alot of variables.

This function is one of the functions that must exist for the framework to
work. Please notice that a pointer to this function has to exist in the
sc_profile struct thatwe have in the bottom of this file.
*/
int c_uncompressed_create(struct sc_context *context, const struct iphdr *ip)
{
        struct sc_uncompressed_context *uncompressed_profile;

        context->profile_context = kmalloc(sizeof(struct sc_uncompressed_context),GFP_ATOMIC);
        if (context->profile_context == 0) {
          rohc_debugf(0,"c_ip_create(): no mem for profile context\n");
          return 0;
        }
        uncompressed_profile = (struct sc_uncompressed_context *)context->profile_context;

        uncompressed_profile->ir_count = 0;
        uncompressed_profile->normal_count = 0;

        uncompressed_profile->go_back_ir_count = 0;
        return 1;

}


/*
Function to deallocate a context.

This function is one of the functions that must exist for the framework to
work. Please notice that a pointer to this function has to exist in the
sc_profile struct thatwe have in the bottom of this file.
*/
void c_uncompressed_destroy(struct sc_context *context){

        if (context->profile_context != 0)
          kfree(context->profile_context);

}

/*
A package can always be sent uncompressed

This function is one of the functions that must exist for the framework to
work. Please notice that a pointer to this function has to exist in the
sc_profile struct that we have in the bottom of this file.
*/
int c_uncompressed_check_context(struct sc_context *context, const struct iphdr *ip){
        return 1;
}

/*
Encode packages to a pattern decided by two different factors.
1. Decide state
2. Code packet

This function is one of the functions that must exist for the framework to
work. Please notice that a pointer to this function has to exist in the
sc_profile struct that we have in the bottom of this file.
*/
int c_uncompressed_encode(struct sc_context *context,
        const struct iphdr *ip,
        int packet_size,
        unsigned char *dest,
        int max_size,
        int *payload_offset)

{
        int size;

        // 1
        uncompressed_decide_state(context);

        //2
        size = uncompressed_code_packet(context,ip,dest,payload_offset,max_size);

        return size;
}

/*
Function that update the profile when feedback has arrived.

This function is one of the functions that must exist for the framework to
work. Please notice that a pointer to this function has to exist in the
sc_profile struct that we have in the bottom of this file.
*/
void c_uncompressed_feedback(struct sc_context *context, struct sc_feedback *feedback)
{
        //struct sc_uncompressed_context *uncompressed_context = (struct sc_uncompressed_context *)context->profile_context;
        unsigned char *p = feedback->data + feedback->specific_offset;

        if (feedback->type == 1) { // ack

        } else if (feedback->type == 2) { // FEEDBACK-2
                unsigned int crc = 0, crc_used=0;

                int sn_not_valid = 0;
                unsigned char mode = (p[0]>>4) & 3;
                unsigned int sn = ((p[0] & 15) << 8) + p[1];
                int remaining = feedback->specific_size-2;
                p+=2;


                while (remaining > 0) {
                        int opt = p[0]>>4;
                        int optlen = p[0] & 0x0f;

                        switch (opt) {
                        case 1: // CRC
                                crc = p[1];
                                crc_used = 1;
                                p[1] = 0; // set to zero for crc computation..
                        break;
                        //case 2: // Reject
                        //break;
                        case 3: // SN-Not-Valid
                                sn_not_valid=1;
                        break;
                        case 4: // SN  -- TODO: how is several SN options combined?
                                sn = (sn<<8) + p[1];
                        break;
                        //case 7: // Loss
                        //break;
                        default:
                                rohc_debugf(0,"c_ip_feedback(): Unknown feedback type: %d\n", opt);
                        break;
                        }

                        remaining -= 1 + optlen;
                        p += 1 + optlen;
                }

                if (crc_used) { // check crc..
                        if (crc_calculate(CRC_TYPE_8, feedback->data, feedback->size ) != crc) {
                                rohc_debugf(0,"c_ip_feedback(): crc check failed..(size=%d)\n", feedback->size);
                                return;
                        }
                }

                if (mode != 0) {
                        if (crc_used) {
                                uncompressed_change_mode(context, mode);
                                rohc_debugf(1,"c_ip_feedback(): changing mode to %d\n", mode);
                        } else {
                                rohc_debugf(0,"c_ip_feedback(): mode change requested but no crc was given..\n");
                        }
                }

                switch (feedback->acktype) {
                case ACK:

                break;

                case NACK:


                break;

                case STATIC_NACK:
                        uncompressed_change_state(context, IR);
                break;

                case RESERVED:
                        rohc_debugf(0, "c_ip_feedback(): reserved field used\n");
                break;
                }

        } else {
                rohc_debugf(0,"c_ip_feedback(): Feedback type not implemented (%d)\n", feedback->type);
        }

}

/* Decide the state we will work in. Observe that RFC3095 defines the states as ir and normal, but here
we call normal state FO instead*/
void uncompressed_decide_state(struct sc_context *context)
{
        struct sc_uncompressed_context *uncompressed_profile = (struct sc_uncompressed_context *)context->profile_context;

        if(context->c_state == IR &&  uncompressed_profile->ir_count >= MAX_IR_COUNT){
                uncompressed_change_state(context, FO);
        }
        if(context->c_mode == U){
                uncompressed_periodic_down_transition(context);
        }
}

/*Function that change state periodicly after a certain number of packets */
void uncompressed_periodic_down_transition(struct sc_context *context)
{
        struct sc_uncompressed_context *uncompressed_profile = (struct sc_uncompressed_context *)context->profile_context;
        if(uncompressed_profile->go_back_ir_count == CHANGE_TO_IR_COUNT){
                uncompressed_profile->go_back_ir_count = 0;
                uncompressed_change_state(context, IR);
        }
        if (context->c_state == FO)
                uncompressed_profile->go_back_ir_count++;

}

// Change the mode of this context
void uncompressed_change_mode(struct sc_context *c, C_MODE new_mode) {
        if(c->c_mode != new_mode){
                c->c_mode = new_mode;
                uncompressed_change_state(c, IR);
        }
}

// Change the state of this context
void uncompressed_change_state(struct sc_context *context, C_STATE new_state)
{

        struct sc_uncompressed_context *uncompressed_profile = (struct sc_uncompressed_context *)context->profile_context;
        // Reset counters only if different state
        if (context->c_state != new_state) {
                uncompressed_profile->ir_count = 0;
                uncompressed_profile->normal_count = 0;

        }

        context->c_state = new_state;
}

/*
Code the packet, it is eiter IR or normal
*/
int uncompressed_code_packet(struct sc_context *context,
        const struct iphdr *ip,
        unsigned char *dest,
        int *payload_offset,
        int max_size){

        struct sc_uncompressed_context *uncompressed_profile = (struct sc_uncompressed_context *)context->profile_context;
        switch(context->c_state){
                case IR:
                        rohc_debugf(1,"uncompressed_code_packet(): IR packet uncomp..\n");
                        uncompressed_profile->ir_count++;
                        return uncompressed_code_IR_packet(context,ip,dest,payload_offset,max_size);
                        break;
                case FO:
                        rohc_debugf(1,"uncompressed_code_packet(): normal packet uncomp..\n");
                        uncompressed_profile->normal_count++;
                        return uncompressed_code_normal_packet(context,ip,dest,payload_offset,max_size);
                        break;
                default:
                        rohc_debugf(0,"uncompressed_code_packet(): Unknown packet..\n");
                        return -1;
        }
}
/*

IR packet (5.10.1)

     0   1   2   3   4   5   6   7
    --- --- --- --- --- --- --- ---
 1 :         Add-CID octet         : if for small CIDs and (CID != 0)
   +---+---+---+---+---+---+---+---+
 2 | 1   1   1   1   1   1   0 |res|
   +---+---+---+---+---+---+---+---+
   :                               :
 3 /    0-2 octets of CID info     / 1-2 octets if for large CIDs
   :                               :
   +---+---+---+---+---+---+---+---+
 4 |          Profile = 0          | 1 octet
   +---+---+---+---+---+---+---+---+
 5 |              CRC              | 1 octet
   +---+---+---+---+---+---+---+---+
   :                               : (optional)
   /           IP packet           / variable length
   :                               :
    --- --- --- --- --- --- --- ---

*/
int uncompressed_code_IR_packet(struct sc_context *context,
        const struct iphdr *ip,
        unsigned char *dest,
        int *payload_offset,
        int max_size){

        int counter = 0;
        int first_position;

        rohc_debugf(2,"Coding IR packet (cid=%d)\n", context->cid);
        //Both 1 and 3, 2 will be placed in dest[first_position]
        counter = code_cid_values(context,dest,max_size,&first_position);

        // 2
        dest[first_position] = 0xfc;

        // 4
        dest[counter] = 0;
        counter++;

        // 5
        dest[counter]= crc_calculate(CRC_TYPE_8,dest,counter);
        counter++;
        *payload_offset = 0;
        return counter;
}
/*

Normal packet (5.10.2)

     0   1   2   3   4   5   6   7
    --- --- --- --- --- --- --- ---
 1 :         Add-CID octet         : if for small CIDs and (CID != 0)
   +---+---+---+---+---+---+---+---+
 2 |   first octet of IP packet    |
   +---+---+---+---+---+---+---+---+
   :                               :
 3 /    0-2 octets of CID info     / 1-2 octets if for large CIDs
   :                               :
   +---+---+---+---+---+---+---+---+
   |                               |
   /      rest of IP packet        / variable length
   |                               |
   +---+---+---+---+---+---+---+---+

*/
int uncompressed_code_normal_packet(struct sc_context *context,
        const struct iphdr *ip,
        unsigned char *dest,
        int *payload_offset,
        int max_size)
{

        int counter = 0;
        int first_position;


        rohc_debugf(2,"Coding normal packet (cid=%d)\n", context->cid);
        //Both 1 and 3, 2 will be placed in dest[first_position]
        counter = code_cid_values(context,dest,max_size,&first_position);

        // 2

        dest[first_position] = ((unsigned char *)ip)[0];

        *payload_offset = 1;
        return counter;
}

/*
A struct thate every function must have the first fieldtell what protocol this profile has.
The second row is the profile id-number, Then two strings that is for printing version and
description. And finaly pointers to functions that have to exist in every profile.
*/
struct sc_profile c_uncompressed_profile = {
        0, // IP-Protocol
        0, // Profile ID
        "1.0b", // Version
        "Uncompressed / Compressor", // Description
        c_uncompressed_create,
        c_uncompressed_destroy,
        c_uncompressed_check_context,
        c_uncompressed_encode,
        c_uncompressed_feedback
};
Revision:	1.1
Committed:	Sun Feb 8 06:02:44 2004 UTC (20 years, 4 months ago) by pcg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	ROHC-IMPORT-2004-02-08
Log Message:	* empty log message *
#	User	Rev	Content
1	pcg	1.1	/*
2			ROHC Project 2003 at Lulea University of Technology, Sweden.
3			Authors: Andreas Vernersson <andver-8@student.luth.se>
4			Daniel Pettersson <danpet-7@student.luth.se>
5			Erik Soderstrom <soderstrom@yahoo.com>
6			Fredrik Lindstrom <frelin-9@student.luth.se>
7			Johan Stenmark <johste-8@student.luth.se>
8			Martin Juhlin <juhlin@users.sourceforge.net>
9			Mikael Larsson <larmik-9@student.luth.se>
10			Robert Maxe <robmax-1@student.luth.se>
11
12			Copyright (C) 2003 Andreas Vernersson, Daniel Pettersson,
13			Erik Soderström, Fredrik Lindström, Johan Stenmark,
14			Martin Juhlin, Mikael Larsson, Robert Maxe.
15
16			This program is free software; you can redistribute it and/or modify
17			it under the terms of the GNU General Public License as published by
18			the Free Software Foundation; either version 2 of the License, or
19			(at your option) any later version.
20
21			This program is distributed in the hope that it will be useful,
22			but WITHOUT ANY WARRANTY; without even the implied warranty of
23			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24			GNU General Public License for more details.
25
26			You should have received a copy of the GNU General Public License
27			along with this program; if not, write to the Free Software
28			Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
29			*/
30			/*
31			* Implementation of the uncompressed profile (compressor)
32			*/
33
34			#include <linux/ip.h>
35
36			#include "rohc.h"
37			#include "comp.h"
38			#include "c_util.h"
39
40
41			/*
42			Structure that contain counters, flags and structures that need to saved between different
43			packages. Every context have one of these
44			*/
45			struct sc_uncompressed_context {
46			int ir_count, normal_count;
47			int go_back_ir_count;
48
49
50			};
51
52			static void uncompressed_decide_state(struct sc_context *context);
53
54			static void uncompressed_periodic_down_transition(struct sc_context *context);
55
56			static void uncompressed_change_mode(struct sc_context *c, C_MODE new_mode);
57
58			static void uncompressed_change_state(struct sc_context *c, C_STATE new_state);
59
60			static int uncompressed_code_packet(struct sc_context *context,
61			const struct iphdr *ip,
62			unsigned char *dest,
63			int *payload_offset,
64			int max_size);
65
66			static int uncompressed_code_IR_packet(struct sc_context *context,
67			const struct iphdr *ip,
68			unsigned char *dest,
69			int *payload_offset,
70			int max_size);
71
72			static int uncompressed_code_normal_packet(struct sc_context *context,
73			const struct iphdr *ip,
74			unsigned char *dest,
75			int *payload_offset,
76			int max_size);
77
78			/*
79			Function to allocate for a new context, it aslo initilize alot of variables.
80
81			This function is one of the functions that must exist for the framework to
82			work. Please notice that a pointer to this function has to exist in the
83			sc_profile struct thatwe have in the bottom of this file.
84			*/
85			int c_uncompressed_create(struct sc_context context, const struct iphdr ip)
86			{
87			struct sc_uncompressed_context *uncompressed_profile;
88
89			context->profile_context = kmalloc(sizeof(struct sc_uncompressed_context),GFP_ATOMIC);
90			if (context->profile_context == 0) {
91			rohc_debugf(0,"c_ip_create(): no mem for profile context\n");
92			return 0;
93			}
94			uncompressed_profile = (struct sc_uncompressed_context *)context->profile_context;
95
96			uncompressed_profile->ir_count = 0;
97			uncompressed_profile->normal_count = 0;
98
99			uncompressed_profile->go_back_ir_count = 0;
100			return 1;
101
102			}
103
104
105			/*
106			Function to deallocate a context.
107
108			This function is one of the functions that must exist for the framework to
109			work. Please notice that a pointer to this function has to exist in the
110			sc_profile struct thatwe have in the bottom of this file.
111			*/
112			void c_uncompressed_destroy(struct sc_context *context){
113
114			if (context->profile_context != 0)
115			kfree(context->profile_context);
116
117			}
118
119			/*
120			A package can always be sent uncompressed
121
122			This function is one of the functions that must exist for the framework to
123			work. Please notice that a pointer to this function has to exist in the
124			sc_profile struct that we have in the bottom of this file.
125			*/
126			int c_uncompressed_check_context(struct sc_context context, const struct iphdr ip){
127			return 1;
128			}
129
130			/*
131			Encode packages to a pattern decided by two different factors.
132			1. Decide state
133			2. Code packet
134
135			This function is one of the functions that must exist for the framework to
136			work. Please notice that a pointer to this function has to exist in the
137			sc_profile struct that we have in the bottom of this file.
138			*/
139			int c_uncompressed_encode(struct sc_context *context,
140			const struct iphdr *ip,
141			int packet_size,
142			unsigned char *dest,
143			int max_size,
144			int *payload_offset)
145
146			{
147			int size;
148
149			// 1
150			uncompressed_decide_state(context);
151
152			//2
153			size = uncompressed_code_packet(context,ip,dest,payload_offset,max_size);
154
155			return size;
156			}
157
158			/*
159			Function that update the profile when feedback has arrived.
160
161			This function is one of the functions that must exist for the framework to
162			work. Please notice that a pointer to this function has to exist in the
163			sc_profile struct that we have in the bottom of this file.
164			*/
165			void c_uncompressed_feedback(struct sc_context context, struct sc_feedback feedback)
166			{
167			//struct sc_uncompressed_context uncompressed_context = (struct sc_uncompressed_context )context->profile_context;
168			unsigned char *p = feedback->data + feedback->specific_offset;
169
170			if (feedback->type == 1) { // ack
171
172			} else if (feedback->type == 2) { // FEEDBACK-2
173			unsigned int crc = 0, crc_used=0;
174
175			int sn_not_valid = 0;
176			unsigned char mode = (p[0]>>4) & 3;
177			unsigned int sn = ((p[0] & 15) << 8) + p[1];
178			int remaining = feedback->specific_size-2;
179			p+=2;
180
181
182			while (remaining > 0) {
183			int opt = p[0]>>4;
184			int optlen = p[0] & 0x0f;
185
186			switch (opt) {
187			case 1: // CRC
188			crc = p[1];
189			crc_used = 1;
190			p[1] = 0; // set to zero for crc computation..
191			break;
192			//case 2: // Reject
193			//break;
194			case 3: // SN-Not-Valid
195			sn_not_valid=1;
196			break;
197			case 4: // SN -- TODO: how is several SN options combined?
198			sn = (sn<<8) + p[1];
199			break;
200			//case 7: // Loss
201			//break;
202			default:
203			rohc_debugf(0,"c_ip_feedback(): Unknown feedback type: %d\n", opt);
204			break;
205			}
206
207			remaining -= 1 + optlen;
208			p += 1 + optlen;
209			}
210
211			if (crc_used) { // check crc..
212			if (crc_calculate(CRC_TYPE_8, feedback->data, feedback->size ) != crc) {
213			rohc_debugf(0,"c_ip_feedback(): crc check failed..(size=%d)\n", feedback->size);
214			return;
215			}
216			}
217
218			if (mode != 0) {
219			if (crc_used) {
220			uncompressed_change_mode(context, mode);
221			rohc_debugf(1,"c_ip_feedback(): changing mode to %d\n", mode);
222			} else {
223			rohc_debugf(0,"c_ip_feedback(): mode change requested but no crc was given..\n");
224			}
225			}
226
227			switch (feedback->acktype) {
228			case ACK:
229
230			break;
231
232			case NACK:
233
234
235			break;
236
237			case STATIC_NACK:
238			uncompressed_change_state(context, IR);
239			break;
240
241			case RESERVED:
242			rohc_debugf(0, "c_ip_feedback(): reserved field used\n");
243			break;
244			}
245
246			} else {
247			rohc_debugf(0,"c_ip_feedback(): Feedback type not implemented (%d)\n", feedback->type);
248			}
249
250			}
251
252			/* Decide the state we will work in. Observe that RFC3095 defines the states as ir and normal, but here
253			we call normal state FO instead*/
254			void uncompressed_decide_state(struct sc_context *context)
255			{
256			struct sc_uncompressed_context uncompressed_profile = (struct sc_uncompressed_context )context->profile_context;
257
258			if(context->c_state == IR && uncompressed_profile->ir_count >= MAX_IR_COUNT){
259			uncompressed_change_state(context, FO);
260			}
261			if(context->c_mode == U){
262			uncompressed_periodic_down_transition(context);
263			}
264			}
265
266			/Function that change state periodicly after a certain number of packets /
267			void uncompressed_periodic_down_transition(struct sc_context *context)
268			{
269			struct sc_uncompressed_context uncompressed_profile = (struct sc_uncompressed_context )context->profile_context;
270			if(uncompressed_profile->go_back_ir_count == CHANGE_TO_IR_COUNT){
271			uncompressed_profile->go_back_ir_count = 0;
272			uncompressed_change_state(context, IR);
273			}
274			if (context->c_state == FO)
275			uncompressed_profile->go_back_ir_count++;
276
277			}
278
279			// Change the mode of this context
280			void uncompressed_change_mode(struct sc_context *c, C_MODE new_mode) {
281			if(c->c_mode != new_mode){
282			c->c_mode = new_mode;
283			uncompressed_change_state(c, IR);
284			}
285			}
286
287			// Change the state of this context
288			void uncompressed_change_state(struct sc_context *context, C_STATE new_state)
289			{
290
291			struct sc_uncompressed_context uncompressed_profile = (struct sc_uncompressed_context )context->profile_context;
292			// Reset counters only if different state
293			if (context->c_state != new_state) {
294			uncompressed_profile->ir_count = 0;
295			uncompressed_profile->normal_count = 0;
296
297			}
298
299			context->c_state = new_state;
300			}
301
302			/*
303			Code the packet, it is eiter IR or normal
304			*/
305			int uncompressed_code_packet(struct sc_context *context,
306			const struct iphdr *ip,
307			unsigned char *dest,
308			int *payload_offset,
309			int max_size){
310
311			struct sc_uncompressed_context uncompressed_profile = (struct sc_uncompressed_context )context->profile_context;
312			switch(context->c_state){
313			case IR:
314			rohc_debugf(1,"uncompressed_code_packet(): IR packet uncomp..\n");
315			uncompressed_profile->ir_count++;
316			return uncompressed_code_IR_packet(context,ip,dest,payload_offset,max_size);
317			break;
318			case FO:
319			rohc_debugf(1,"uncompressed_code_packet(): normal packet uncomp..\n");
320			uncompressed_profile->normal_count++;
321			return uncompressed_code_normal_packet(context,ip,dest,payload_offset,max_size);
322			break;
323			default:
324			rohc_debugf(0,"uncompressed_code_packet(): Unknown packet..\n");
325			return -1;
326			}
327			}
328			/*
329
330			IR packet (5.10.1)
331
332			0 1 2 3 4 5 6 7
333			--- --- --- --- --- --- --- ---
334			1 : Add-CID octet : if for small CIDs and (CID != 0)
335			+---+---+---+---+---+---+---+---+
336			2 \| 1 1 1 1 1 1 0 \|res\|
337			+---+---+---+---+---+---+---+---+
338			: :
339			3 / 0-2 octets of CID info / 1-2 octets if for large CIDs
340			: :
341			+---+---+---+---+---+---+---+---+
342			4 \| Profile = 0 \| 1 octet
343			+---+---+---+---+---+---+---+---+
344			5 \| CRC \| 1 octet
345			+---+---+---+---+---+---+---+---+
346			: : (optional)
347			/ IP packet / variable length
348			: :
349			--- --- --- --- --- --- --- ---
350
351			*/
352			int uncompressed_code_IR_packet(struct sc_context *context,
353			const struct iphdr *ip,
354			unsigned char *dest,
355			int *payload_offset,
356			int max_size){
357
358			int counter = 0;
359			int first_position;
360
361			rohc_debugf(2,"Coding IR packet (cid=%d)\n", context->cid);
362			//Both 1 and 3, 2 will be placed in dest[first_position]
363			counter = code_cid_values(context,dest,max_size,&first_position);
364
365			// 2
366			dest[first_position] = 0xfc;
367
368			// 4
369			dest[counter] = 0;
370			counter++;
371
372			// 5
373			dest[counter]= crc_calculate(CRC_TYPE_8,dest,counter);
374			counter++;
375			*payload_offset = 0;
376			return counter;
377			}
378			/*
379
380			Normal packet (5.10.2)
381
382			0 1 2 3 4 5 6 7
383			--- --- --- --- --- --- --- ---
384			1 : Add-CID octet : if for small CIDs and (CID != 0)
385			+---+---+---+---+---+---+---+---+
386			2 \| first octet of IP packet \|
387			+---+---+---+---+---+---+---+---+
388			: :
389			3 / 0-2 octets of CID info / 1-2 octets if for large CIDs
390			: :
391			+---+---+---+---+---+---+---+---+
392			\| \|
393			/ rest of IP packet / variable length
394			\| \|
395			+---+---+---+---+---+---+---+---+
396
397			*/
398			int uncompressed_code_normal_packet(struct sc_context *context,
399			const struct iphdr *ip,
400			unsigned char *dest,
401			int *payload_offset,
402			int max_size)
403			{
404
405			int counter = 0;
406			int first_position;
407
408
409			rohc_debugf(2,"Coding normal packet (cid=%d)\n", context->cid);
410			//Both 1 and 3, 2 will be placed in dest[first_position]
411			counter = code_cid_values(context,dest,max_size,&first_position);
412
413			// 2
414
415			dest[first_position] = ((unsigned char *)ip)[0];
416
417			*payload_offset = 1;
418			return counter;
419			}
420
421			/*
422			A struct thate every function must have the first fieldtell what protocol this profile has.
423			The second row is the profile id-number, Then two strings that is for printing version and
424			description. And finaly pointers to functions that have to exist in every profile.
425			*/
426			struct sc_profile c_uncompressed_profile = {
427			0, // IP-Protocol
428			0, // Profile ID
429			"1.0b", // Version
430			"Uncompressed / Compressor", // Description
431			c_uncompressed_create,
432			c_uncompressed_destroy,
433			c_uncompressed_check_context,
434			c_uncompressed_encode,
435			c_uncompressed_feedback
436			};