1 /*
2 * Copyright (c) 2022 Trackunit Corporation
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 */
6
7 /*************************************************************************************************/
8 /* Dependencies */
9 /*************************************************************************************************/
10 #include <zephyr/ztest.h>
11 #include <zephyr/kernel.h>
12 #include <zephyr/net/net_if.h>
13 #include <zephyr/net/net_pkt.h>
14 #include <zephyr/net/net_l2.h>
15 #include <zephyr/net/ethernet.h>
16 #include <zephyr/net/ppp.h>
17 #include <zephyr/sys/crc.h>
18 #include <string.h>
19
20 #include <zephyr/modem/ppp.h>
21 #include <modem_backend_mock.h>
22
23 #define TEST_MODEM_PPP_BUF_SIZE (16)
24 #define TEST_MODEM_PPP_TX_PKT_BUF_SIZE (5)
25 #define TEST_MODEM_PPP_MOCK_PIPE_RX_BUF_SIZE (4096)
26 #define TEST_MODEM_PPP_MOCK_PIPE_TX_BUF_SIZE (4096)
27
28 #define TEST_MODEM_PPP_IP_FRAME_SEND_MULT_N (5)
29 #define TEST_MODEM_PPP_IP_FRAME_SEND_LARGE_N (2048)
30 #define TEST_MODEM_PPP_IP_FRAME_RECEIVE_LARGE_N (2048)
31
32 /*************************************************************************************************/
33 /* Mock pipe */
34 /*************************************************************************************************/
35 static struct modem_backend_mock mock;
36 static uint8_t mock_rx_buf[TEST_MODEM_PPP_MOCK_PIPE_RX_BUF_SIZE];
37 static uint8_t mock_tx_buf[TEST_MODEM_PPP_MOCK_PIPE_TX_BUF_SIZE];
38 static struct modem_pipe *mock_pipe;
39
40 /*************************************************************************************************/
41 /* PPP frames */
42 /*************************************************************************************************/
43 static uint8_t ppp_frame_wrapped[] = {0x7E, 0xFF, 0x7D, 0x23, 0xC0, 0x21, 0x7D, 0x21, 0x7D,
44 0x21, 0x7D, 0x20, 0x7D, 0x24, 0xD1, 0xB5, 0x7E};
45
46 static uint8_t ppp_frame_unwrapped[] = {0xC0, 0x21, 0x01, 0x01, 0x00, 0x04};
47
48 static uint8_t ip_frame_wrapped[] = {
49 0x7E, 0xFF, 0x7D, 0x23, 0x7D, 0x20, 0x21, 0x45, 0x7D, 0x20, 0x7D, 0x20, 0x29, 0x87, 0x6E,
50 0x40, 0x7D, 0x20, 0xE8, 0x7D, 0x31, 0xC1, 0xE9, 0x7D, 0x23, 0xFB, 0x7D, 0x25, 0x20, 0x7D,
51 0x2A, 0x2B, 0x36, 0x26, 0x25, 0x7D, 0x32, 0x8C, 0x3E, 0x7D, 0x20, 0x7D, 0x35, 0xBD, 0xF3,
52 0x2D, 0x7D, 0x20, 0x7D, 0x2B, 0x7D, 0x20, 0x7D, 0x27, 0x7D, 0x20, 0x7D, 0x24, 0x7D, 0x20,
53 0x7D, 0x24, 0x7D, 0x2A, 0x7D, 0x20, 0x7D, 0x2A, 0x7D, 0x20, 0xD4, 0x31, 0x7E};
54
55 static uint8_t ip_frame_unwrapped[] = {
56 0x45, 0x00, 0x00, 0x29, 0x87, 0x6E, 0x40, 0x00, 0xE8, 0x11, 0xC1, 0xE9, 0x03, 0xFB,
57 0x05, 0x20, 0x0A, 0x2B, 0x36, 0x26, 0x25, 0x12, 0x8C, 0x3E, 0x00, 0x15, 0xBD, 0xF3,
58 0x2D, 0x00, 0x0B, 0x00, 0x07, 0x00, 0x04, 0x00, 0x04, 0x0A, 0x00, 0x0A, 0x00};
59
60 static uint8_t ip_frame_unwrapped_with_protocol[] = {
61 0x00, 0x21, 0x45, 0x00, 0x00, 0x29, 0x87, 0x6E, 0x40, 0x00, 0xE8, 0x11, 0xC1, 0xE9, 0x03,
62 0xFB, 0x05, 0x20, 0x0A, 0x2B, 0x36, 0x26, 0x25, 0x12, 0x8C, 0x3E, 0x00, 0x15, 0xBD, 0xF3,
63 0x2D, 0x00, 0x0B, 0x00, 0x07, 0x00, 0x04, 0x00, 0x04, 0x0A, 0x00, 0x0A, 0x00};
64
65 static uint8_t corrupt_start_end_ppp_frame_wrapped[] = {0x2A, 0x46, 0x7E, 0x7E, 0xFF, 0x7D, 0x23,
66 0xC0, 0x21, 0x7D, 0x21, 0x7D, 0x21, 0x7D,
67 0x20, 0x7D, 0x24, 0xD1, 0xB5, 0x7E};
68
69 /*************************************************************************************************/
70 /* Buffers */
71 /*************************************************************************************************/
72 static struct net_pkt *received_packets[12];
73 static size_t received_packets_len;
74 static uint8_t buffer[4096];
75 static uint8_t unwrapped_buffer[4096];
76 static uint8_t wrapped_buffer[4096];
77
78 /*************************************************************************************************/
79 /* Mock network interface */
80 /*************************************************************************************************/
test_net_l2_recv(struct net_if * iface,struct net_pkt * pkt)81 static enum net_verdict test_net_l2_recv(struct net_if *iface, struct net_pkt *pkt)
82 {
83 /* Validate buffer not overflowing */
84 zassert_true(received_packets_len < ARRAY_SIZE(received_packets),
85 "Mock network interface receive buffer limit reached");
86
87 /* Store pointer to received packet */
88 received_packets[received_packets_len] = pkt;
89 received_packets_len++;
90 return NET_OK;
91 }
92
93 /* This emulates the layer two API */
94 static struct net_l2 test_net_l2 = {
95 .recv = test_net_l2_recv,
96 };
97
98 /* This emulates the network interface device which will receive unwrapped network packets */
99 static struct net_if_dev test_net_if_dev = {
100 .l2 = &test_net_l2,
101 .link_addr.addr = {0x00, 0x00, 0x5E, 0x00, 0x53, 0x01},
102 .link_addr.len = NET_ETH_ADDR_LEN,
103 .link_addr.type = NET_LINK_DUMMY,
104 .mtu = 1500,
105 .oper_state = NET_IF_OPER_UP,
106 };
107
108 /* This emulates the network interface which contains the network interface device */
109 static struct net_if test_iface = {
110 .if_dev = &test_net_if_dev,
111 };
112
113 /*************************************************************************************************/
114 /* Modem PPP */
115 /*************************************************************************************************/
116 /*
117 * The following initialization happens automatically when MODEM_PPP_DEFINE is used. However,
118 * since we are emulating the network interface, we can't use that macro, and have to initialize
119 * it manually here.
120 */
121 static uint8_t ppp_receive_buf[TEST_MODEM_PPP_BUF_SIZE];
122 static uint8_t ppp_transmit_buf[TEST_MODEM_PPP_BUF_SIZE];
123
124 static struct modem_ppp ppp = {
125 .iface = &test_iface,
126 .receive_buf = ppp_receive_buf,
127 .transmit_buf = ppp_transmit_buf,
128 .buf_size = TEST_MODEM_PPP_BUF_SIZE,
129 };
130
131 /*************************************************************************************************/
132 /* Modem PPP net device */
133 /*************************************************************************************************/
134 extern const struct ppp_api modem_ppp_ppp_api;
135 static const struct device ppp_net_dev = {.data = &ppp};
test_net_send(struct net_pkt * pkt)136 static int test_net_send(struct net_pkt *pkt)
137 {
138 return modem_ppp_ppp_api.send(&ppp_net_dev, pkt);
139 }
140
141 /*************************************************************************************************/
142 /* Helpers */
143 /*************************************************************************************************/
test_modem_ppp_prng_random(bool reset)144 static uint8_t test_modem_ppp_prng_random(bool reset)
145 {
146 static uint32_t prng_state = 1234;
147
148 if (reset == true) {
149 prng_state = 1234;
150 }
151
152 prng_state = (1103515245 * prng_state + 12345) % (1 << 31);
153 return (uint8_t)(prng_state & 0xFF);
154 }
155
test_modem_ppp_fill_net_pkt(struct net_pkt * pkt,size_t size)156 static size_t test_modem_ppp_fill_net_pkt(struct net_pkt *pkt, size_t size)
157 {
158 test_modem_ppp_prng_random(true);
159
160 for (size_t i = 0; i < size; i++) {
161 if (net_pkt_write_u8(pkt, test_modem_ppp_prng_random(false)) < 0) {
162 return i;
163 }
164 }
165
166 return size;
167 }
168
test_modem_ppp_unwrap(uint8_t * unwrapped,const uint8_t * wrapped,size_t wrapped_size)169 static size_t test_modem_ppp_unwrap(uint8_t *unwrapped, const uint8_t *wrapped, size_t wrapped_size)
170 {
171 size_t wrapped_pos = 4;
172 size_t unwrapped_pos = 0;
173
174 while (wrapped_pos < (wrapped_size - 1)) {
175 /* Escape byte */
176 if (wrapped[wrapped_pos] == 0x7D) {
177 unwrapped[unwrapped_pos] = wrapped[wrapped_pos + 1] ^ 0x20;
178 wrapped_pos += 2;
179 unwrapped_pos += 1;
180 continue;
181 }
182
183 /* Normal byte */
184 unwrapped[unwrapped_pos] = wrapped[wrapped_pos];
185 wrapped_pos += 1;
186 unwrapped_pos += 1;
187 }
188
189 /* Remove FCS */
190 unwrapped_pos -= 2;
191 return unwrapped_pos;
192 }
193
test_modem_ppp_validate_fill(const uint8_t * data,size_t size)194 static bool test_modem_ppp_validate_fill(const uint8_t *data, size_t size)
195 {
196 test_modem_ppp_prng_random(true);
197
198 for (size_t i = 0; i < size; i++) {
199 if (data[i] != test_modem_ppp_prng_random(false)) {
200 return false;
201 }
202 }
203
204 return true;
205 }
206
test_modem_ppp_generate_ppp_frame(uint8_t * frame,size_t size)207 static void test_modem_ppp_generate_ppp_frame(uint8_t *frame, size_t size)
208 {
209 uint8_t byte;
210 uint16_t fcs;
211
212 test_modem_ppp_prng_random(true);
213
214 byte = 0x03;
215 fcs = crc16_ccitt(0xFFFF, &byte, 0x01);
216
217 frame[0] = 0x00;
218 frame[1] = 0x21;
219
220 for (size_t i = 2; i < (size - 2); i++) {
221 byte = test_modem_ppp_prng_random(false);
222 frame[i] = byte;
223 }
224
225 fcs = crc16_ccitt(fcs, frame, size) ^ 0xFFFF;
226
227 frame[size - 2] = fcs >> 8;
228 frame[size - 1] = fcs;
229 }
230
test_modem_ppp_wrap_ppp_frame(uint8_t * wrapped,const uint8_t * frame,size_t size)231 static size_t test_modem_ppp_wrap_ppp_frame(uint8_t *wrapped, const uint8_t *frame, size_t size)
232 {
233 size_t wrapped_pos = 4;
234
235 wrapped[0] = 0x7E;
236 wrapped[1] = 0xFF;
237 wrapped[2] = 0x7D;
238 wrapped[3] = 0x23;
239
240 for (size_t i = 0; i < size; i++) {
241 if ((frame[i] == 0x7E) || (frame[i] == 0x7D) || (frame[i] < 0x20)) {
242 wrapped[wrapped_pos] = 0x7D;
243 wrapped[wrapped_pos + 1] = frame[i] ^ 0x20;
244 wrapped_pos += 2;
245 continue;
246 }
247
248 wrapped[wrapped_pos] = frame[i];
249 wrapped_pos += 1;
250 }
251
252 wrapped[wrapped_pos] = 0x7E;
253 wrapped_pos += 1;
254 return wrapped_pos;
255 }
256
257 /*************************************************************************************************/
258 /* Test setup */
259 /*************************************************************************************************/
test_modem_ppp_setup(void)260 static void *test_modem_ppp_setup(void)
261 {
262 /*
263 * Manually run internal init function which would normally be performed by kernel as
264 * result of using the macro MODEM_PPP_DEFINE()
265 */
266 zassert_true(modem_ppp_init_internal(&ppp_net_dev) == 0, "Failed to run internal init");
267 net_if_flag_set(modem_ppp_get_iface(&ppp), NET_IF_UP);
268
269 const struct modem_backend_mock_config mock_config = {
270 .rx_buf = mock_rx_buf,
271 .rx_buf_size = sizeof(mock_rx_buf),
272 .tx_buf = mock_tx_buf,
273 .tx_buf_size = sizeof(mock_tx_buf),
274 .limit = 8,
275 };
276
277 mock_pipe = modem_backend_mock_init(&mock, &mock_config);
278 zassert_true(modem_pipe_open(mock_pipe, K_SECONDS(10)) == 0, "Failed to open mock pipe");
279 modem_ppp_attach(&ppp, mock_pipe);
280 return NULL;
281 }
282
test_modem_ppp_before(void * f)283 static void test_modem_ppp_before(void *f)
284 {
285 /* Unreference packets */
286 for (size_t i = 0; i < received_packets_len; i++) {
287 net_pkt_unref(received_packets[i]);
288 }
289
290 /* Reset packets received buffer */
291 received_packets_len = 0;
292
293 /* Reset mock pipe */
294 modem_backend_mock_reset(&mock);
295 }
296
297 /*************************************************************************************************/
298 /* Tests */
299 /*************************************************************************************************/
ZTEST(modem_ppp,test_ppp_frame_receive)300 ZTEST(modem_ppp, test_ppp_frame_receive)
301 {
302 struct net_pkt *pkt;
303 size_t pkt_len;
304
305 /* Put wrapped frame */
306 modem_backend_mock_put(&mock, ppp_frame_wrapped, sizeof(ppp_frame_wrapped));
307
308 /* Give modem ppp time to process received frame */
309 k_msleep(1000);
310
311 /* Validate frame received on mock network interface */
312 zassert_true(received_packets_len == 1, "Expected to receive one network packet");
313
314 pkt = received_packets[0];
315 pkt_len = net_pkt_get_len(pkt);
316
317 /* Validate length of received frame */
318 zassert_true(pkt_len == sizeof(ppp_frame_unwrapped), "Received net pkt data len incorrect");
319
320 /* Validate data of received frame */
321 net_pkt_cursor_init(pkt);
322 net_pkt_read(pkt, buffer, pkt_len);
323
324 zassert_true(memcmp(buffer, ppp_frame_unwrapped, pkt_len) == 0,
325 "Recevied net pkt data incorrect");
326 }
327
ZTEST(modem_ppp,test_corrupt_start_end_ppp_frame_receive)328 ZTEST(modem_ppp, test_corrupt_start_end_ppp_frame_receive)
329 {
330 struct net_pkt *pkt;
331 size_t pkt_len;
332
333 /* Put wrapped frame */
334 modem_backend_mock_put(&mock, corrupt_start_end_ppp_frame_wrapped,
335 sizeof(corrupt_start_end_ppp_frame_wrapped));
336
337 /* Give modem ppp time to process received frame */
338 k_msleep(1000);
339
340 /* Validate frame received on mock network interface */
341 zassert_true(received_packets_len == 1, "Expected to receive one network packet");
342
343 /* Validate length of received frame */
344 pkt = received_packets[0];
345 pkt_len = net_pkt_get_len(pkt);
346 zassert_true(pkt_len == sizeof(ppp_frame_unwrapped), "Received net pkt data len incorrect");
347
348 /* Validate data of received frame */
349 net_pkt_cursor_init(pkt);
350 net_pkt_read(pkt, buffer, pkt_len);
351 zassert_true(memcmp(buffer, ppp_frame_unwrapped, pkt_len) == 0,
352 "Recevied net pkt data incorrect");
353 }
354
ZTEST(modem_ppp,test_ppp_frame_send)355 ZTEST(modem_ppp, test_ppp_frame_send)
356 {
357 struct net_pkt *pkt;
358 int ret;
359
360 /* Allocate net pkt */
361 pkt = net_pkt_alloc_with_buffer(&test_iface, 256, AF_UNSPEC, 0, K_NO_WAIT);
362
363 zassert_true(pkt != NULL, "Failed to allocate network packet");
364
365 /* Set network packet data */
366 net_pkt_cursor_init(pkt);
367 ret = net_pkt_write(pkt, ppp_frame_unwrapped, sizeof(ppp_frame_unwrapped));
368 zassert_true(ret == 0, "Failed to write data to allocated network packet");
369 net_pkt_set_ppp(pkt, true);
370
371 /* Send network packet */
372 zassert_true(test_net_send(pkt) == 0, "Failed to send PPP pkt");
373
374 /* Give modem ppp time to wrap and send frame */
375 k_msleep(1000);
376
377 /* Get any sent data */
378 ret = modem_backend_mock_get(&mock, buffer, sizeof(buffer));
379 zassert_true(ret == sizeof(ppp_frame_wrapped), "Wrapped frame length incorrect");
380 zassert_true(memcmp(buffer, ppp_frame_wrapped, ret) == 0,
381 "Wrapped frame content is incorrect");
382 }
383
ZTEST(modem_ppp,test_ip_frame_receive)384 ZTEST(modem_ppp, test_ip_frame_receive)
385 {
386 struct net_pkt *pkt;
387 size_t pkt_len;
388
389 /* Put wrapped frame */
390 modem_backend_mock_put(&mock, ip_frame_wrapped, sizeof(ip_frame_wrapped));
391
392 /* Give modem ppp time to process received frame */
393 k_msleep(1000);
394
395 /* Validate frame received on mock network interface */
396 zassert_true(received_packets_len == 1, "Expected to receive one network packet");
397 pkt = received_packets[0];
398 pkt_len = net_pkt_get_len(pkt);
399
400 /* Validate length of received frame */
401 zassert_true(pkt_len == sizeof(ip_frame_unwrapped_with_protocol),
402 "Received net pkt data len incorrect");
403
404 /* Validate data of received frame */
405 net_pkt_cursor_init(pkt);
406 net_pkt_read(pkt, buffer, pkt_len);
407 zassert_true(memcmp(buffer, ip_frame_unwrapped_with_protocol, pkt_len) == 0,
408 "Recevied net pkt data incorrect");
409 }
410
ZTEST(modem_ppp,test_ip_frame_send)411 ZTEST(modem_ppp, test_ip_frame_send)
412 {
413 struct net_pkt *pkt;
414 int ret;
415
416 /* Allocate net pkt */
417 pkt = net_pkt_alloc_with_buffer(&test_iface, 256, AF_UNSPEC, 0, K_NO_WAIT);
418 zassert_true(pkt != NULL, "Failed to allocate network packet");
419
420 /* Set network packet data */
421 net_pkt_cursor_init(pkt);
422 ret = net_pkt_write(pkt, ip_frame_unwrapped, sizeof(ip_frame_unwrapped));
423 zassert_true(ret == 0, "Failed to write data to allocated network packet");
424 net_pkt_set_family(pkt, AF_INET);
425
426 /* Send network packet */
427 test_net_send(pkt);
428
429 /* Give modem ppp time to wrap and send frame */
430 k_msleep(100);
431
432 /* Get any sent data */
433 ret = modem_backend_mock_get(&mock, buffer, sizeof(buffer));
434 zassert_true(ret == sizeof(ip_frame_wrapped), "Wrapped frame length incorrect");
435 zassert_true(memcmp(buffer, ip_frame_wrapped, ret) == 0,
436 "Wrapped frame content is incorrect");
437 }
438
ZTEST(modem_ppp,test_ip_frame_send_multiple)439 ZTEST(modem_ppp, test_ip_frame_send_multiple)
440 {
441 struct net_pkt *pkts[TEST_MODEM_PPP_IP_FRAME_SEND_MULT_N];
442 int ret;
443
444 /* Allocate net pkts */
445 for (uint8_t i = 0; i < TEST_MODEM_PPP_IP_FRAME_SEND_MULT_N; i++) {
446 pkts[i] = net_pkt_alloc_with_buffer(&test_iface, 256, AF_UNSPEC, 0, K_NO_WAIT);
447 zassert_true(pkts[i] != NULL, "Failed to allocate network packet");
448 net_pkt_cursor_init(pkts[i]);
449 ret = net_pkt_write(pkts[i], ip_frame_unwrapped, sizeof(ip_frame_unwrapped));
450 zassert_true(ret == 0, "Failed to write data to allocated network packet");
451 net_pkt_set_family(pkts[i], AF_INET);
452 }
453
454 /* Send net pkts */
455 for (uint8_t i = 0; i < TEST_MODEM_PPP_IP_FRAME_SEND_MULT_N; i++) {
456 test_net_send(pkts[i]);
457 }
458
459 k_msleep(100);
460
461 ret = modem_backend_mock_get(&mock, buffer, TEST_MODEM_PPP_MOCK_PIPE_RX_BUF_SIZE);
462 zassert_true(ret == (sizeof(ip_frame_wrapped) * TEST_MODEM_PPP_IP_FRAME_SEND_MULT_N),
463 "Incorrect data amount received");
464 }
465
ZTEST(modem_ppp,test_ip_frame_send_large)466 ZTEST(modem_ppp, test_ip_frame_send_large)
467 {
468 struct net_pkt *pkt;
469 size_t size;
470 int ret;
471
472 pkt = net_pkt_alloc_with_buffer(&test_iface, TEST_MODEM_PPP_IP_FRAME_SEND_LARGE_N,
473 AF_UNSPEC, 0, K_NO_WAIT);
474
475 net_pkt_cursor_init(pkt);
476 net_pkt_set_family(pkt, AF_INET);
477 size = test_modem_ppp_fill_net_pkt(pkt, TEST_MODEM_PPP_IP_FRAME_SEND_LARGE_N);
478 zassert_true(size == TEST_MODEM_PPP_IP_FRAME_SEND_LARGE_N, "Failed to fill net pkt");
479 test_net_send(pkt);
480 k_msleep(TEST_MODEM_PPP_IP_FRAME_SEND_LARGE_N * 2);
481
482 /* Data + protocol */
483 ret = modem_backend_mock_get(&mock, buffer, TEST_MODEM_PPP_MOCK_PIPE_RX_BUF_SIZE);
484 size = test_modem_ppp_unwrap(unwrapped_buffer, buffer, ret);
485 zassert_true(size == (TEST_MODEM_PPP_IP_FRAME_SEND_LARGE_N + 2),
486 "Incorrect data amount received");
487
488 /* Validate protocol */
489 zassert_true(unwrapped_buffer[0] == 0x00, "Incorrect protocol");
490 zassert_true(unwrapped_buffer[1] == 0x21, "Incorrect protocol");
491
492 /* Validate data */
493 zassert_true(test_modem_ppp_validate_fill(&unwrapped_buffer[2], (size - 2)) == true,
494 "Incorrect data received");
495 }
496
ZTEST(modem_ppp,test_ip_frame_receive_large)497 ZTEST(modem_ppp, test_ip_frame_receive_large)
498 {
499 struct net_pkt *pkt;
500 size_t size;
501 size_t pkt_len;
502
503 test_modem_ppp_generate_ppp_frame(buffer, TEST_MODEM_PPP_IP_FRAME_RECEIVE_LARGE_N);
504 size = test_modem_ppp_wrap_ppp_frame(wrapped_buffer, buffer,
505 TEST_MODEM_PPP_IP_FRAME_RECEIVE_LARGE_N);
506
507 zassert_true(size > TEST_MODEM_PPP_IP_FRAME_RECEIVE_LARGE_N, "Failed to wrap data");
508 modem_backend_mock_put(&mock, wrapped_buffer, size);
509
510 k_msleep(TEST_MODEM_PPP_IP_FRAME_RECEIVE_LARGE_N * 2);
511
512 zassert_true(received_packets_len == 1, "Expected to receive one network packet");
513 pkt = received_packets[0];
514 pkt_len = net_pkt_get_len(pkt);
515
516 /* FCS is removed from packet data */
517 zassert_true(pkt_len == (TEST_MODEM_PPP_IP_FRAME_RECEIVE_LARGE_N - 2),
518 "Incorrect length of net packet received");
519 }
520
521 ZTEST_SUITE(modem_ppp, NULL, test_modem_ppp_setup, test_modem_ppp_before, NULL, NULL);
522
