Loading...
Searching...
No Matches
rules.h
1/*
2 * Copyright (C) 2018 imec IDLab
3 * Copyright (C) 2022 Freie Universität Berlin
4 *
5 * This program is free software: you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation, either version 3 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program. If not, see <http://www.gnu.org/licenses/>.
17 */
18
24#ifndef RULES_RULES_H
25#define RULES_RULES_H
26
27#include "kernel_defines.h"
28
29#include "schc.h"
30#ifdef USE_COAP
31#include "net/coap.h"
32#endif
33
34#ifdef __cplusplus
35extern "C" {
36#endif
37
38#if USE_IP6
39static const struct schc_ipv6_rule_t ipv6_rule1 = {
40 .up = 10, .down = 10, .length = 11,
41 {
42 /* field, ML, len, pos, dir, val, MO, CDA */
43 { IP6_V, 0, 4, 1, BI, {6}, &mo_equal, NOTSENT },
44 { IP6_TC, 0, 8, 1, BI, {0}, &mo_ignore, NOTSENT },
45 { IP6_FL, 0, 20, 1, BI, {0, 0, 0}, &mo_ignore, NOTSENT },
46 { IP6_LEN, 0, 16, 1, BI, {0, 0}, &mo_ignore, COMPLENGTH },
47 { IP6_NH, 0, 8, 1, BI, {17}, &mo_equal, NOTSENT },
48 { IP6_HL, 0, 8, 1, UP, {64}, &mo_equal, NOTSENT },
49 { IP6_HL, 0, 8, 1, DOWN, {0}, &mo_ignore, VALUESENT },
50 { IP6_DEVPRE, 0, 64, 1, BI, {
51 0x20, 0x01, 0x0d, 0xb8, 0x00, 0x01, 0x00, 0x00
52 }, &mo_equal, NOTSENT },
53 { IP6_DEVIID, 0, 64, 1, BI, {
54 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01
55 }, &mo_equal, NOTSENT },
56 { IP6_APPPRE, 4, 64, 1, BI, {
57 /* you can store as many IPs as (MAX_FIELD_LENGTH / 8) */
58 0x20, 0x01, 0x0d, 0xb8, 0x00, 0x01, 0x00, 0x00,
59 0x20, 0x01, 0x0d, 0xb8, 0x00, 0x02, 0x00, 0x00,
60 0x20, 0x01, 0x0d, 0xb8, 0x00, 0x03, 0x00, 0x00,
61 0x20, 0x01, 0x0d, 0xb8, 0x00, 0x04, 0x00, 0x00
62 }, &mo_matchmap, MAPPINGSENT },
63 { IP6_APPIID, 0, 64, 1, BI, {
64 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02
65 }, &mo_equal, NOTSENT },
66 }
67};
68
69/* link local test rule */
70static const struct schc_ipv6_rule_t ipv6_rule2 = {
71 .up = 10, .down = 10, .length = 10,
72 {
73 /* field, ML, len, pos, dir, val, MO, CDA */
74 { IP6_V, 0, 4, 1, BI, {6}, &mo_equal, NOTSENT },
75 { IP6_TC, 0, 8, 1, BI, {0}, &mo_ignore, NOTSENT },
76 { IP6_FL, 0, 20, 1, BI, {0, 0, 0}, &mo_ignore, NOTSENT },
77 { IP6_LEN, 0, 16, 1, BI, {0, 0}, &mo_ignore, COMPLENGTH },
78 { IP6_NH, 2, 8, 1, BI, {17, 58}, &mo_matchmap, MAPPINGSENT },
79 { IP6_HL, 2, 8, 1, BI, {64, 255}, &mo_matchmap, NOTSENT },
80 { IP6_DEVPRE, 0, 64, 1, BI, {
81 0xFE, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
82 }, &mo_equal, NOTSENT },
83 { IP6_DEVIID, 62, 64, 1, BI, {
84 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01
85 }, &mo_MSB, LSB },
86 { IP6_APPPRE, 0, 64, 1, BI, {
87 0xFE, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
88 }, &mo_equal, NOTSENT },
89 { IP6_APPIID, 62, 64, 1, BI, {
90 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01
91 }, &mo_MSB, LSB },
92 }
93};
94#endif
95
96#if USE_UDP
97static const struct schc_udp_rule_t udp_rule1 = {
98 .up = 4, .down = 4, .length = 4,
99 {
100 /* field, ML, len, pos, dir, val, MO, CDA */
101 /* set field length to 16 to indicate 16 bit values
102 * MO param length to 2 to indicate 2 indices */
103 { UDP_DEV, 2, 16, 1, BI, {
104 0x33, 0x16, /* 5683 or */
105 0x33, 0x17 /* 5684 */
106 }, &mo_matchmap, MAPPINGSENT },
107 { UDP_APP, 2, 16, 1, BI, {
108 0x33, 0x16, /* 5683 or */
109 0x33, 0x17 /* 5684 */
110 }, &mo_matchmap, MAPPINGSENT },
111 { UDP_LEN, 0, 16, 1, BI, {0, 0}, &mo_ignore, COMPLENGTH },
112 { UDP_CHK, 0, 16, 1, BI, {0, 0}, &mo_ignore, COMPCHK },
113 }
114};
115
116static const struct schc_udp_rule_t udp_rule2 = {
117 .up = 4, .down = 4, .length = 4,
118 {
119 /* field, ML, len, pos, dir, val, MO, CDA */
120 { UDP_DEV, 12, 16, 1, BI, {0x1F, 0x40}, &mo_MSB, LSB },
121 { UDP_APP, 12, 16, 1, BI, {0x1F, 0x40}, &mo_MSB, LSB },
122 { UDP_LEN, 0, 16, 1, BI, {0, 0}, &mo_ignore, COMPLENGTH },
123 { UDP_CHK, 0, 16, 1, BI, {0, 0}, &mo_ignore, COMPCHK },
124 }
125};
126
127static const struct schc_udp_rule_t udp_rule3 = {
128 .up = 4, .down = 4, .length = 4,
129 {
130 /* field, ML, len, pos, dir, val, MO, CDA */
131 { UDP_DEV, 0, 16, 1, BI, {0x13, 0x89}, &mo_equal, NOTSENT },
132 { UDP_APP, 0, 16, 1, BI, {0x13, 0x88}, &mo_equal, NOTSENT },
133 { UDP_LEN, 0, 16, 1, BI, {0, 0}, &mo_ignore, COMPLENGTH },
134 { UDP_CHK, 0, 16, 1, BI, {0, 0}, &mo_ignore, COMPCHK },
135 }
136};
137#endif
138
139#if USE_COAP
140/* It is important to use strings, identical to the ones defined in coap.h for the options. */
141
142/* GET /usage */
143static const struct schc_coap_rule_t coap_rule1 = {
144 .up = 9, .down = 7, .length = 9,
145 {
146 /* field, ML, len, pos, dir, val, MO, CDA */
147 { COAP_V, 0, 2, 1, BI, {COAP_V1}, &mo_equal, NOTSENT },
148 /* the MO_param_length (ML) is used to indicate the true length of the list */
149 { COAP_T, 4, 2, 1, BI, {
150 COAP_TYPE_CON, COAP_TYPE_NON, COAP_TYPE_ACK, COAP_TYPE_RST
151 }, &mo_matchmap, MAPPINGSENT },
152 { COAP_TKL, 0, 4, 1, BI, {4}, &mo_equal, NOTSENT },
153 { COAP_C, 0, 8, 1, BI, {COAP_METHOD_PUT}, &mo_equal, NOTSENT },
154 { COAP_MID, 0, 16, 1, BI, {0x23, 0xBB}, &mo_equal, NOTSENT },
155 { COAP_TKN, 24, 32, 1, BI, {
156 0x21, 0xFA, 0x01, 0x00
157 }, &mo_MSB, LSB },
158 { COAP_URIPATH, 0, 40, 1, BI, "usage", &mo_equal, NOTSENT },
159 { COAP_NORESP, 0, 8, 1, BI, {0x1A}, &mo_equal, NOTSENT },
160 { COAP_PAYLOAD, 0, 8, 1, BI, {0xFF}, &mo_equal, NOTSENT }
161 }
162};
163
164/* POST temperature value */
165static const struct schc_coap_rule_t coap_rule2 = {
166 .up = 7, .down = 7, .length = 10,
167 {
168 /* field, ML, len, pos, dir, val, MO, CDA */
169 { COAP_V, 0, 2, 1, BI, {COAP_V1}, &mo_equal, NOTSENT },
170 { COAP_T, 0, 2, 1, BI, {0}, &mo_ignore, VALUESENT },
171 { COAP_TKL, 0, 4, 1, BI, {4}, &mo_equal, NOTSENT },
172 { COAP_C, 0, 8, 1, UP, {COAP_CODE_CONTENT}, &mo_equal, NOTSENT },
173 { COAP_C, 0, 8, 1, DOWN, {COAP_METHOD_GET}, &mo_equal, NOTSENT },
174 /* match the first 12 bits */
175 { COAP_MID, 12, 16, 1, UP, {0x23, 0xBB}, &mo_MSB, LSB },
176 { COAP_MID, 0, 16, 1, DOWN, {0, 0}, &mo_ignore, VALUESENT },
177 { COAP_TKN, 0, 32, 1, BI, {0, 0, 0, 0}, &mo_ignore, VALUESENT },
178 { COAP_URIPATH, 0, 32, 1, DOWN, "temp", &mo_equal, NOTSENT },
179 /* respond with CONTENT */
180 { COAP_PAYLOAD, 0, 8, 1, UP, {0xFF}, &mo_equal, NOTSENT }
181 }
182};
183
184static const struct schc_coap_rule_t coap_rule3 = {
185 .up = 1, .down = 1, .length = 1,
186 {
187 /* field, ML, len, pos, dir, val, MO, CDA */
188 { COAP_V, 0, 2, 1, BI, {COAP_V1}, &mo_equal, NOTSENT },
189 }
190};
191
192static const struct schc_coap_rule_t coap_rule4 = {
193 .up = 12, .down = 12, .length = 12,
194 {
195 /* field, ML, len, pos, dir, val, MO, CDA */
196 { COAP_V, 0, 2, 1, BI, {COAP_V1}, &mo_equal, NOTSENT },
197 { COAP_T, 0, 2, 1, BI, {COAP_TYPE_CON}, &mo_equal, NOTSENT },
198 { COAP_TKL, 0, 4, 1, BI, {8}, &mo_equal, NOTSENT },
199 { COAP_C, 0, 8, 1, BI, {COAP_METHOD_POST}, &mo_equal, NOTSENT },
200 { COAP_MID, 0, 16, 1, BI, {0x23, 0xBB}, &mo_ignore, VALUESENT },
201 /* match the 24 first bits, send the last 8 */
202 { COAP_TKN, 24, 32, 1, BI, {
203 0x21, 0xFA, 0x01, 0x00
204 }, &mo_MSB, LSB },
205 { COAP_URIPATH, 0, 16, 1, BI, "rd", &mo_equal, NOTSENT },
206 { COAP_CONTENTF, 0, 8, 1, BI, {0x28}, &mo_equal, NOTSENT },
207 { COAP_URIQUERY, 0, 72, 1, BI, "lwm2m=1.0", &mo_equal, NOTSENT },
208 { COAP_URIQUERY, 0, 88, 1, BI, "ep=magician", &mo_equal, NOTSENT },
209 { COAP_URIQUERY, 0, 48, 1, BI, "lt=121", &mo_equal, NOTSENT },
210 /* respond with CONTENT */
211 { COAP_PAYLOAD, 0, 8, 1, BI, {0xff}, &mo_equal, NOTSENT }
212 }
213};
214#endif
215
216static const struct schc_compression_rule_t comp_rule_1 = {
217 .rule_id = 0x01,
218 .rule_id_size_bits = 8U,
219#if USE_IP6
220 &ipv6_rule1,
221#endif
222#if USE_UDP
223 &udp_rule1,
224#endif
225#if USE_COAP
226 &coap_rule1,
227#endif
228};
229
230static const struct schc_compression_rule_t comp_rule_2 = {
231 .rule_id = 0x02,
232 .rule_id_size_bits = 8U,
233#if USE_IP6
234 &ipv6_rule1,
235#endif
236#if USE_UDP
237 &udp_rule3,
238#endif
239#if USE_COAP
240 &coap_rule2,
241#endif
242};
243
244static const struct schc_compression_rule_t comp_rule_3 = {
245 .rule_id = 0x03,
246 .rule_id_size_bits = 8U,
247#if USE_IP6
248 &ipv6_rule2,
249#endif
250#if USE_UDP
251 &udp_rule2,
252#endif
253#if USE_COAP
254 &coap_rule3,
255#endif
256};
257
258static const struct schc_compression_rule_t comp_rule_4 = {
259 .rule_id = 0x04,
260 .rule_id_size_bits = 8U,
261#if USE_IP6
262 &ipv6_rule2,
263#endif
264#if USE_UDP
265 &udp_rule2,
266#endif
267#if USE_COAP
268 &coap_rule4,
269#endif
270};
271
272static const struct schc_fragmentation_rule_t frag_rule_21 = {
273 .rule_id = 21,
274 .rule_id_size_bits = 8,
275 .mode = NO_ACK,
276 .dir = BI,
277 .FCN_SIZE = 1, /* FCN size */
278 .MAX_WND_FCN = 0, /* Maximum fragments per window */
279 .WINDOW_SIZE = 0, /* Window size */
280 .DTAG_SIZE = 0, /* DTAG size */
281};
282
283static const struct schc_fragmentation_rule_t frag_rule_22 = {
284 .rule_id = 22,
285 .rule_id_size_bits = 8,
286 .mode = ACK_ON_ERROR,
287 .dir = BI,
288 .FCN_SIZE = 3, /* FCN size */
289 .MAX_WND_FCN = 6, /* Maximum fragments per window */
290 .WINDOW_SIZE = 1, /* Window size */
291 .DTAG_SIZE = 0, /* DTAG size */
292};
293
294static const struct schc_fragmentation_rule_t frag_rule_23 = {
295 .rule_id = 23,
296 .rule_id_size_bits = 8,
297 .mode = ACK_ALWAYS,
298 .dir = BI,
299 .FCN_SIZE = 3, /* FCN size */
300 .MAX_WND_FCN = 6, /* Maximum fragments per window */
301 .WINDOW_SIZE = 1, /* Window size */
302 .DTAG_SIZE = 0, /* DTAG size */
303};
304
305/* save compression rules in flash */
306static const struct schc_compression_rule_t* node1_compression_rules[] = {
307 &comp_rule_1, &comp_rule_2, &comp_rule_3, &comp_rule_4
308};
309
310/* save fragmentation rules in flash */
311static const struct schc_fragmentation_rule_t* node1_fragmentation_rules[] = {
312 &frag_rule_21, &frag_rule_22, &frag_rule_23,
313};
314
315/* rules for a particular device */
316static const struct schc_device node1 = {
317 .device_id = 1,
318 .uncomp_rule_id = 0,
319 .uncomp_rule_id_size_bits = 8,
320 .compression_rule_count = ARRAY_SIZE(node1_compression_rules),
321 .compression_context = &node1_compression_rules,
322 .fragmentation_rule_count = ARRAY_SIZE(node1_fragmentation_rules),
323 .fragmentation_context = &node1_fragmentation_rules
324};
325static const struct schc_device node2 = {
326 .device_id = 2,
327 .uncomp_rule_id = 0,
328 .uncomp_rule_id_size_bits = 8,
329 .compression_rule_count = ARRAY_SIZE(node1_compression_rules),
330 .compression_context = &node1_compression_rules,
331 .fragmentation_rule_count = ARRAY_SIZE(node1_fragmentation_rules),
332 .fragmentation_context = &node1_fragmentation_rules
333};
334
335/* server keeps track of multiple devices: add devices to device list */
336static const struct schc_device* devices[] = { &node1, &node2 };
337
338#define DEVICE_COUNT ((int)ARRAY_SIZE(devices))
339
340#ifdef __cplusplus
341}
342#endif
343
344#endif /* RULES_RULES_H */
ARRAY_SIZE
#define ARRAY_SIZE(a)
Calculate the number of elements in a static array.
Definition container.h:83
COAP_V1
#define COAP_V1
Identifier for CoAP version 1 (RFC 7252)
Definition coap.h:39
COAP_METHOD_GET
@ COAP_METHOD_GET
GET request (no paylod)
Definition coap.h:172
COAP_METHOD_PUT
@ COAP_METHOD_PUT
PUT request (update resource with payload)
Definition coap.h:174
COAP_METHOD_POST
@ COAP_METHOD_POST
POST request (resource processes payload)
Definition coap.h:173
kernel_defines.h
Common macros and compiler attributes/pragmas configuration.
coap.h
Generic CoAP values as defined by RFC7252.