source: mainline/uspace/srv/net/slip/slip.c@ 5de852c

serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 5de852c was b4edc96, checked in by Jiri Svoboda <jiri@…>, 4 years ago

Rename and move addr48_t to eth_addr_t
  • Property mode set to 100644
File size: 10.3 KB
Line 
1/*
2 * Copyright (c) 2021 Jiri Svoboda
3 * Copyright (c) 2013 Jakub Jermar
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * - Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * - Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * - The name of the author may not be used to endorse or promote products
16 * derived from this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30/** @addtogroup slip
31 * @{
32 */
33/**
34 * @file
35 * @brief IP over serial line IP link provider.
36 */
37
38#include <stdio.h>
39#include <stdint.h>
40#include <stdlib.h>
41#include <loc.h>
42#include <inet/addr.h>
43#include <inet/eth_addr.h>
44#include <inet/iplink_srv.h>
45#include <io/chardev.h>
46#include <io/log.h>
47#include <errno.h>
48#include <str_error.h>
49#include <task.h>
50
51#define NAME "slip"
52#define CAT_IPLINK "iplink"
53
54#define SLIP_MTU 1006 /* as per RFC 1055 */
55
56#define SLIP_END 0300
57#define SLIP_ESC 0333
58#define SLIP_ESC_END 0334
59#define SLIP_ESC_ESC 0335
60
61static errno_t slip_open(iplink_srv_t *);
62static errno_t slip_close(iplink_srv_t *);
63static errno_t slip_send(iplink_srv_t *, iplink_sdu_t *);
64static errno_t slip_send6(iplink_srv_t *, iplink_sdu6_t *);
65static errno_t slip_get_mtu(iplink_srv_t *, size_t *);
66static errno_t slip_get_mac48(iplink_srv_t *, eth_addr_t *);
67static errno_t slip_addr_add(iplink_srv_t *, inet_addr_t *);
68static errno_t slip_addr_remove(iplink_srv_t *, inet_addr_t *);
69
70static iplink_srv_t slip_iplink;
71
72static iplink_ops_t slip_iplink_ops = {
73 .open = slip_open,
74 .close = slip_close,
75 .send = slip_send,
76 .send6 = slip_send6,
77 .get_mtu = slip_get_mtu,
78 .get_mac48 = slip_get_mac48,
79 .addr_add = slip_addr_add,
80 .addr_remove = slip_addr_remove
81};
82
83static uint8_t slip_send_buf[SLIP_MTU + 2];
84static size_t slip_send_pending;
85
86static uint8_t slip_recv_buf[SLIP_MTU + 2];
87static size_t slip_recv_pending;
88static size_t slip_recv_read;
89
90errno_t slip_open(iplink_srv_t *srv)
91{
92 log_msg(LOG_DEFAULT, LVL_DEBUG, "slip_open()");
93 return EOK;
94}
95
96errno_t slip_close(iplink_srv_t *srv)
97{
98 log_msg(LOG_DEFAULT, LVL_DEBUG, "slip_close()");
99 return EOK;
100}
101
102static void write_flush(chardev_t *chardev)
103{
104 size_t written = 0;
105
106 while (slip_send_pending > 0) {
107 errno_t rc;
108 size_t nwr;
109
110 rc = chardev_write(chardev, &slip_send_buf[written],
111 slip_send_pending, &nwr);
112 if (rc != EOK) {
113 log_msg(LOG_DEFAULT, LVL_ERROR,
114 "chardev_write() -> %s", str_error_name(rc));
115 slip_send_pending = 0;
116 break;
117 }
118 written += nwr;
119 slip_send_pending -= nwr;
120 }
121}
122
123static void write_buffered(chardev_t *chardev, uint8_t ch)
124{
125 if (slip_send_pending == sizeof(slip_send_buf))
126 write_flush(chardev);
127 slip_send_buf[slip_send_pending++] = ch;
128}
129
130errno_t slip_send(iplink_srv_t *srv, iplink_sdu_t *sdu)
131{
132 log_msg(LOG_DEFAULT, LVL_DEBUG, "slip_send()");
133
134 chardev_t *chardev = (chardev_t *) srv->arg;
135 uint8_t *data = sdu->data;
136
137 /*
138 * Strictly speaking, this is not prescribed by the RFC, but the RFC
139 * suggests to start with sending a SLIP_END byte as a synchronization
140 * measure for dealing with previous possible noise on the line.
141 */
142 write_buffered(chardev, SLIP_END);
143
144 for (size_t i = 0; i < sdu->size; i++) {
145 switch (data[i]) {
146 case SLIP_END:
147 write_buffered(chardev, SLIP_ESC);
148 write_buffered(chardev, SLIP_ESC_END);
149 break;
150 case SLIP_ESC:
151 write_buffered(chardev, SLIP_ESC);
152 write_buffered(chardev, SLIP_ESC_ESC);
153 break;
154 default:
155 write_buffered(chardev, data[i]);
156 break;
157 }
158 }
159
160 write_buffered(chardev, SLIP_END);
161 write_flush(chardev);
162
163 return EOK;
164}
165
166errno_t slip_send6(iplink_srv_t *srv, iplink_sdu6_t *sdu)
167{
168 log_msg(LOG_DEFAULT, LVL_DEBUG, "slip_send6()");
169
170 return ENOTSUP;
171}
172
173errno_t slip_get_mtu(iplink_srv_t *srv, size_t *mtu)
174{
175 log_msg(LOG_DEFAULT, LVL_DEBUG, "slip_get_mtu()");
176 *mtu = SLIP_MTU;
177 return EOK;
178}
179
180errno_t slip_get_mac48(iplink_srv_t *src, eth_addr_t *mac)
181{
182 log_msg(LOG_DEFAULT, LVL_DEBUG, "slip_get_mac48()");
183 return ENOTSUP;
184}
185
186errno_t slip_addr_add(iplink_srv_t *srv, inet_addr_t *addr)
187{
188 log_msg(LOG_DEFAULT, LVL_DEBUG, "slip_addr_add()");
189 return EOK;
190}
191
192errno_t slip_addr_remove(iplink_srv_t *srv, inet_addr_t *addr)
193{
194 log_msg(LOG_DEFAULT, LVL_DEBUG, "slip_addr_remove()");
195 return EOK;
196}
197
198static void usage(void)
199{
200 printf("Usage: " NAME " <service-name> <link-name>\n");
201}
202
203static void slip_client_conn(ipc_call_t *icall, void *arg)
204{
205 log_msg(LOG_DEFAULT, LVL_DEBUG, "slip_client_conn()");
206 iplink_conn(icall, &slip_iplink);
207}
208
209static uint8_t read_buffered(chardev_t *chardev)
210{
211 while (slip_recv_pending == 0) {
212 errno_t rc;
213 size_t nread;
214
215 rc = chardev_read(chardev, slip_recv_buf,
216 sizeof(slip_recv_buf), &nread, chardev_f_none);
217 if (rc != EOK) {
218 log_msg(LOG_DEFAULT, LVL_ERROR,
219 "char_dev_read() -> %s", str_error_name(rc));
220 }
221
222 if (nread == 0)
223 return SLIP_END;
224
225 slip_recv_pending = nread;
226 slip_recv_read = 0;
227 }
228 slip_recv_pending--;
229 return slip_recv_buf[slip_recv_read++];
230}
231
232static errno_t slip_recv_fibril(void *arg)
233{
234 chardev_t *chardev = (chardev_t *) arg;
235 static uint8_t recv_final[SLIP_MTU];
236 iplink_recv_sdu_t sdu;
237 uint8_t ch;
238 errno_t rc;
239
240 sdu.data = recv_final;
241
242 while (true) {
243 sdu.size = 0;
244 while (sdu.size < sizeof(recv_final)) {
245 ch = read_buffered(chardev);
246 switch (ch) {
247 case SLIP_END:
248 if (sdu.size == 0) {
249 /*
250 * Discard the empty SLIP datagram.
251 */
252 break;
253 }
254 goto pass;
255
256 case SLIP_ESC:
257 ch = read_buffered(chardev);
258 if (ch == SLIP_ESC_END) {
259 recv_final[sdu.size++] = SLIP_END;
260 break;
261 } else if (ch == SLIP_ESC_ESC) {
262 recv_final[sdu.size++] = SLIP_ESC;
263 break;
264 }
265
266 /*
267 * The RFC suggests to simply insert the wrongly
268 * escaped character into the packet so we fall
269 * through.
270 */
271 /* Fallthrough */
272
273 default:
274 recv_final[sdu.size++] = ch;
275 break;
276 }
277
278 }
279
280 /*
281 * We have reached the limit of our MTU. Regardless of whether
282 * the datagram is properly ended with SLIP_END, pass it along.
283 * If the next character is really SLIP_END, nothing
284 * catastrophic happens. The algorithm will just see an
285 * artificially empty SLIP datagram and life will go on.
286 */
287
288 pass:
289 rc = iplink_ev_recv(&slip_iplink, &sdu, ip_v4);
290 if (rc != EOK) {
291 log_msg(LOG_DEFAULT, LVL_ERROR,
292 "iplink_ev_recv() -> %s", str_error_name(rc));
293 }
294 }
295
296 return 0;
297}
298
299static errno_t slip_init(const char *svcstr, const char *linkstr)
300{
301 service_id_t svcid;
302 service_id_t linksid;
303 category_id_t iplinkcid;
304 async_sess_t *sess_in = NULL;
305 async_sess_t *sess_out = NULL;
306 chardev_t *chardev_in = NULL;
307 chardev_t *chardev_out = NULL;
308 fid_t fid;
309 errno_t rc;
310
311 iplink_srv_init(&slip_iplink);
312 slip_iplink.ops = &slip_iplink_ops;
313
314 async_set_fallback_port_handler(slip_client_conn, NULL);
315
316 rc = loc_server_register(NAME);
317 if (rc != EOK) {
318 log_msg(LOG_DEFAULT, LVL_ERROR,
319 "Failed registering server.");
320 return rc;
321 }
322
323 rc = loc_service_get_id(svcstr, &svcid, 0);
324 if (rc != EOK) {
325 log_msg(LOG_DEFAULT, LVL_ERROR,
326 "Failed getting ID for service %s", svcstr);
327 return rc;
328 }
329
330 rc = loc_category_get_id(CAT_IPLINK, &iplinkcid, 0);
331 if (rc != EOK) {
332 log_msg(LOG_DEFAULT, LVL_ERROR,
333 "Failed to get category ID for %s",
334 CAT_IPLINK);
335 return rc;
336 }
337
338 /*
339 * Create two sessions to allow to both read and write from the
340 * char_dev at the same time.
341 */
342 sess_out = loc_service_connect(svcid, INTERFACE_DDF, 0);
343 if (!sess_out) {
344 log_msg(LOG_DEFAULT, LVL_ERROR,
345 "Failed to connect to service %s (ID=%d)",
346 svcstr, (int) svcid);
347 return ENOENT;
348 }
349
350 rc = chardev_open(sess_out, &chardev_out);
351 if (rc != EOK) {
352 log_msg(LOG_DEFAULT, LVL_ERROR,
353 "Failed opening character device.");
354 return ENOENT;
355 }
356
357 slip_iplink.arg = chardev_out;
358
359 sess_in = loc_service_connect(svcid, INTERFACE_DDF, 0);
360 if (!sess_in) {
361 log_msg(LOG_DEFAULT, LVL_ERROR,
362 "Failed to connect to service %s (ID=%d)",
363 svcstr, (int) svcid);
364 rc = ENOENT;
365 goto fail;
366 }
367
368 rc = chardev_open(sess_in, &chardev_in);
369 if (rc != EOK) {
370 log_msg(LOG_DEFAULT, LVL_ERROR,
371 "Failed opening character device.");
372 return ENOENT;
373 }
374
375 rc = loc_service_register(linkstr, &linksid);
376 if (rc != EOK) {
377 log_msg(LOG_DEFAULT, LVL_ERROR,
378 "Failed to register service %s",
379 linkstr);
380 goto fail;
381 }
382
383 rc = loc_service_add_to_cat(linksid, iplinkcid);
384 if (rc != EOK) {
385 log_msg(LOG_DEFAULT, LVL_ERROR,
386 "Failed to add service %d (%s) to category %d (%s).",
387 (int) linksid, linkstr, (int) iplinkcid, CAT_IPLINK);
388 goto fail;
389 }
390
391 fid = fibril_create(slip_recv_fibril, chardev_in);
392 if (!fid) {
393 log_msg(LOG_DEFAULT, LVL_ERROR,
394 "Failed to create receive fibril.");
395 rc = ENOENT;
396 goto fail;
397 }
398 fibril_add_ready(fid);
399
400 return EOK;
401
402fail:
403 chardev_close(chardev_out);
404 if (sess_out)
405 async_hangup(sess_out);
406 chardev_close(chardev_in);
407 if (sess_in)
408 async_hangup(sess_in);
409
410 /*
411 * We assume that our registration at the location service will be
412 * cleaned up automatically as the service (i.e. this task) terminates.
413 */
414
415 return rc;
416}
417
418int main(int argc, char *argv[])
419{
420 errno_t rc;
421
422 printf(NAME ": IP over serial line service\n");
423
424 if (argc != 3) {
425 usage();
426 return EINVAL;
427 }
428
429 rc = log_init(NAME);
430 if (rc != EOK) {
431 printf(NAME ": failed to initialize log\n");
432 return rc;
433 }
434
435 rc = slip_init(argv[1], argv[2]);
436 if (rc != EOK)
437 return 1;
438
439 printf(NAME ": Accepting connections.\n");
440 task_retval(0);
441 async_manager();
442
443 /* not reached */
444 return 0;
445}
446
447/** @}
448 */
Note: See TracBrowser for help on using the repository browser.