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