source: mainline/uspace/srv/net/udp/service.c@ eed4139

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since eed4139 was eed4139, checked in by Jakub Jermar <jakub@…>, 7 years ago

Fix some comments mentioning 'call IDs'
  • Property mode set to 100644
File size: 18.3 KB
Line 
1/*
2 * Copyright (c) 2015 Jiri Svoboda
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29/** @addtogroup udp
30 * @{
31 */
32
33/**
34 * @file HelenOS service implementation
35 */
36
37#include <async.h>
38#include <errno.h>
39#include <inet/endpoint.h>
40#include <io/log.h>
41#include <ipc/services.h>
42#include <ipc/udp.h>
43#include <loc.h>
44#include <macros.h>
45#include <stdlib.h>
46
47#include "assoc.h"
48#include "msg.h"
49#include "service.h"
50#include "udp_type.h"
51
52#define NAME "udp"
53
54/** Maximum message size */
55#define MAX_MSG_SIZE DATA_XFER_LIMIT
56
57static void udp_cassoc_recv_msg(void *, inet_ep2_t *, udp_msg_t *);
58
59/** Callbacks to tie us to association layer */
60static udp_assoc_cb_t udp_cassoc_cb = {
61 .recv_msg = udp_cassoc_recv_msg
62};
63
64/** Add message to client receive queue.
65 *
66 * @param cassoc Client association
67 * @param epp Endpoint pair on which message was received
68 * @param msg Message
69 *
70 * @return EOK on success, ENOMEM if out of memory
71 */
72static errno_t udp_cassoc_queue_msg(udp_cassoc_t *cassoc, inet_ep2_t *epp,
73 udp_msg_t *msg)
74{
75 udp_crcv_queue_entry_t *rqe;
76
77 log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_cassoc_queue_msg(%p, %p, %p)",
78 cassoc, epp, msg);
79
80 rqe = calloc(1, sizeof(udp_crcv_queue_entry_t));
81 if (rqe == NULL)
82 return ENOMEM;
83
84 link_initialize(&rqe->link);
85 rqe->epp = *epp;
86 rqe->msg = msg;
87 rqe->cassoc = cassoc;
88
89// fibril_mutex_lock(&assoc->lock);
90 list_append(&rqe->link, &cassoc->client->crcv_queue);
91// fibril_mutex_unlock(&assoc->lock);
92
93// fibril_condvar_broadcast(&assoc->rcv_queue_cv);
94
95 return EOK;
96}
97
98/** Send 'data' event to client.
99 *
100 * @param client Client
101 */
102static void udp_ev_data(udp_client_t *client)
103{
104 async_exch_t *exch;
105
106 log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_ev_data()");
107
108 exch = async_exchange_begin(client->sess);
109 aid_t req = async_send_0(exch, UDP_EV_DATA, NULL);
110 async_exchange_end(exch);
111
112 async_forget(req);
113}
114
115/** Create client association.
116 *
117 * This effectively adds an association into a client's namespace.
118 *
119 * @param client Client
120 * @param assoc Association
121 * @param rcassoc Place to store pointer to new client association
122 *
123 * @return EOK on soccess, ENOMEM if out of memory
124 */
125static errno_t udp_cassoc_create(udp_client_t *client, udp_assoc_t *assoc,
126 udp_cassoc_t **rcassoc)
127{
128 udp_cassoc_t *cassoc;
129 sysarg_t id;
130
131 cassoc = calloc(1, sizeof(udp_cassoc_t));
132 if (cassoc == NULL)
133 return ENOMEM;
134
135 /* Allocate new ID */
136 id = 0;
137 list_foreach (client->cassoc, lclient, udp_cassoc_t, cassoc) {
138 if (cassoc->id >= id)
139 id = cassoc->id + 1;
140 }
141
142 cassoc->id = id;
143 cassoc->client = client;
144 cassoc->assoc = assoc;
145
146 list_append(&cassoc->lclient, &client->cassoc);
147 *rcassoc = cassoc;
148 return EOK;
149}
150
151/** Destroy client association.
152 *
153 * @param cassoc Client association
154 */
155static void udp_cassoc_destroy(udp_cassoc_t *cassoc)
156{
157 list_remove(&cassoc->lclient);
158 free(cassoc);
159}
160
161/** Get client association by ID.
162 *
163 * @param client Client
164 * @param id Client association ID
165 * @param rcassoc Place to store pointer to client association
166 *
167 * @return EOK on success, ENOENT if no client association with the given ID
168 * is found.
169 */
170static errno_t udp_cassoc_get(udp_client_t *client, sysarg_t id,
171 udp_cassoc_t **rcassoc)
172{
173 list_foreach (client->cassoc, lclient, udp_cassoc_t, cassoc) {
174 if (cassoc->id == id) {
175 *rcassoc = cassoc;
176 return EOK;
177 }
178 }
179
180 return ENOENT;
181}
182
183/** Message received on client association.
184 *
185 * Used as udp_assoc_cb.recv_msg callback.
186 *
187 * @param arg Callback argument, client association
188 * @param epp Endpoint pair where message was received
189 * @param msg Message
190 */
191static void udp_cassoc_recv_msg(void *arg, inet_ep2_t *epp, udp_msg_t *msg)
192{
193 udp_cassoc_t *cassoc = (udp_cassoc_t *) arg;
194
195 udp_cassoc_queue_msg(cassoc, epp, msg);
196 udp_ev_data(cassoc->client);
197}
198
199/** Create association.
200 *
201 * Handle client request to create association (with parameters unmarshalled).
202 *
203 * @param client UDP client
204 * @param epp Endpoint pair
205 * @param rassoc_id Place to store ID of new association
206 *
207 * @return EOK on success or an error code
208 */
209static errno_t udp_assoc_create_impl(udp_client_t *client, inet_ep2_t *epp,
210 sysarg_t *rassoc_id)
211{
212 udp_assoc_t *assoc;
213 udp_cassoc_t *cassoc;
214 errno_t rc;
215
216 log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_create_impl");
217
218 assoc = udp_assoc_new(epp, NULL, NULL);
219 if (assoc == NULL)
220 return EIO;
221
222 if (epp->local_link != 0)
223 udp_assoc_set_iplink(assoc, epp->local_link);
224
225 rc = udp_cassoc_create(client, assoc, &cassoc);
226 if (rc != EOK) {
227 assert(rc == ENOMEM);
228 udp_assoc_delete(assoc);
229 return ENOMEM;
230 }
231
232 assoc->cb = &udp_cassoc_cb;
233 assoc->cb_arg = cassoc;
234
235 rc = udp_assoc_add(assoc);
236 if (rc != EOK) {
237 udp_cassoc_destroy(cassoc);
238 udp_assoc_delete(assoc);
239 return rc;
240 }
241
242 *rassoc_id = cassoc->id;
243 return EOK;
244}
245
246/** Destroy association.
247 *
248 * Handle client request to destroy association (with parameters unmarshalled).
249 *
250 * @param client UDP client
251 * @param assoc_id Association ID
252 * @return EOK on success, ENOENT if no such association is found
253 */
254static errno_t udp_assoc_destroy_impl(udp_client_t *client, sysarg_t assoc_id)
255{
256 udp_cassoc_t *cassoc;
257 errno_t rc;
258
259 rc = udp_cassoc_get(client, assoc_id, &cassoc);
260 if (rc != EOK) {
261 assert(rc == ENOENT);
262 return ENOENT;
263 }
264
265 udp_assoc_remove(cassoc->assoc);
266 udp_assoc_reset(cassoc->assoc);
267 udp_assoc_delete(cassoc->assoc);
268 udp_cassoc_destroy(cassoc);
269 return EOK;
270}
271
272/** Set association sending messages with no local address.
273 *
274 * Handle client request to set nolocal flag (with parameters unmarshalled).
275 *
276 * @param client UDP client
277 * @param assoc_id Association ID
278 * @return EOK on success, ENOENT if no such association is found
279 */
280static errno_t udp_assoc_set_nolocal_impl(udp_client_t *client, sysarg_t assoc_id)
281{
282 udp_cassoc_t *cassoc;
283 errno_t rc;
284
285 rc = udp_cassoc_get(client, assoc_id, &cassoc);
286 if (rc != EOK) {
287 assert(rc == ENOENT);
288 return ENOENT;
289 }
290
291 log_msg(LOG_DEFAULT, LVL_NOTE, "Setting nolocal to true");
292 cassoc->assoc->nolocal = true;
293 return EOK;
294}
295
296/** Send message via association.
297 *
298 * Handle client request to send message (with parameters unmarshalled).
299 *
300 * @param client UDP client
301 * @param assoc_id Association ID
302 * @param dest Destination endpoint or @c NULL to use the default from
303 * association
304 * @param data Message data
305 * @param size Message size
306 *
307 * @return EOK on success or an error code
308 */
309static errno_t udp_assoc_send_msg_impl(udp_client_t *client, sysarg_t assoc_id,
310 inet_ep_t *dest, void *data, size_t size)
311{
312 udp_msg_t msg;
313 udp_cassoc_t *cassoc;
314 errno_t rc;
315
316 rc = udp_cassoc_get(client, assoc_id, &cassoc);
317 if (rc != EOK)
318 return rc;
319
320 msg.data = data;
321 msg.data_size = size;
322 rc = udp_assoc_send(cassoc->assoc, dest, &msg);
323 if (rc != EOK)
324 return rc;
325
326 return EOK;
327}
328
329/** Create callback session.
330 *
331 * Handle client request to create callback session.
332 *
333 * @param client UDP client
334 * @param iid Async request ID
335 * @param icall Async request data
336 */
337static void udp_callback_create_srv(udp_client_t *client, cap_call_handle_t icall_handle,
338 ipc_call_t *icall)
339{
340 log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_callback_create_srv()");
341
342 async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE);
343 if (sess == NULL) {
344 async_answer_0(icall_handle, ENOMEM);
345 return;
346 }
347
348 client->sess = sess;
349 async_answer_0(icall_handle, EOK);
350}
351
352/** Create association.
353 *
354 * Handle client request to create association.
355 *
356 * @param client UDP client
357 * @param iid Async request ID
358 * @param icall Async request data
359 */
360static void udp_assoc_create_srv(udp_client_t *client, cap_call_handle_t icall_handle,
361 ipc_call_t *icall)
362{
363 cap_call_handle_t chandle;
364 size_t size;
365 inet_ep2_t epp;
366 sysarg_t assoc_id;
367 errno_t rc;
368
369 log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_create_srv()");
370
371 if (!async_data_write_receive(&chandle, &size)) {
372 async_answer_0(chandle, EREFUSED);
373 async_answer_0(icall_handle, EREFUSED);
374 return;
375 }
376
377 if (size != sizeof(inet_ep2_t)) {
378 async_answer_0(chandle, EINVAL);
379 async_answer_0(icall_handle, EINVAL);
380 return;
381 }
382
383 rc = async_data_write_finalize(chandle, &epp, size);
384 if (rc != EOK) {
385 async_answer_0(chandle, rc);
386 async_answer_0(icall_handle, rc);
387 return;
388 }
389
390 rc = udp_assoc_create_impl(client, &epp, &assoc_id);
391 if (rc != EOK) {
392 async_answer_0(icall_handle, rc);
393 return;
394 }
395
396 async_answer_1(icall_handle, EOK, assoc_id);
397}
398
399/** Destroy association.
400 *
401 * Handle client request to destroy association.
402 *
403 * @param client UDP client
404 * @param iid Async request ID
405 * @param icall Async request data
406 */
407static void udp_assoc_destroy_srv(udp_client_t *client, cap_call_handle_t icall_handle,
408 ipc_call_t *icall)
409{
410 sysarg_t assoc_id;
411 errno_t rc;
412
413 log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_destroy_srv()");
414
415 assoc_id = IPC_GET_ARG1(*icall);
416 rc = udp_assoc_destroy_impl(client, assoc_id);
417 async_answer_0(icall_handle, rc);
418}
419
420/** Set association with no local address.
421 *
422 * Handle client request to set no local address flag.
423 *
424 * @param client UDP client
425 * @param iid Async request ID
426 * @param icall Async request data
427 */
428static void udp_assoc_set_nolocal_srv(udp_client_t *client, cap_call_handle_t icall_handle,
429 ipc_call_t *icall)
430{
431 sysarg_t assoc_id;
432 errno_t rc;
433
434 log_msg(LOG_DEFAULT, LVL_NOTE, "udp_assoc_set_nolocal_srv()");
435
436 assoc_id = IPC_GET_ARG1(*icall);
437 rc = udp_assoc_set_nolocal_impl(client, assoc_id);
438 async_answer_0(icall_handle, rc);
439}
440
441/** Send message via association.
442 *
443 * Handle client request to send message.
444 *
445 * @param client UDP client
446 * @param iid Async request ID
447 * @param icall Async request data
448 */
449static void udp_assoc_send_msg_srv(udp_client_t *client, cap_call_handle_t icall_handle,
450 ipc_call_t *icall)
451{
452 cap_call_handle_t chandle;
453 size_t size;
454 inet_ep_t dest;
455 sysarg_t assoc_id;
456 void *data;
457 errno_t rc;
458
459 log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_send_msg_srv()");
460
461 /* Receive dest */
462
463 if (!async_data_write_receive(&chandle, &size)) {
464 async_answer_0(chandle, EREFUSED);
465 async_answer_0(icall_handle, EREFUSED);
466 return;
467 }
468
469 if (size != sizeof(inet_ep_t)) {
470 async_answer_0(chandle, EINVAL);
471 async_answer_0(icall_handle, EINVAL);
472 return;
473 }
474
475 rc = async_data_write_finalize(chandle, &dest, size);
476 if (rc != EOK) {
477 async_answer_0(chandle, rc);
478 async_answer_0(icall_handle, rc);
479 return;
480 }
481
482 /* Receive message data */
483
484 if (!async_data_write_receive(&chandle, &size)) {
485 async_answer_0(chandle, EREFUSED);
486 async_answer_0(icall_handle, EREFUSED);
487 return;
488 }
489
490 if (size > MAX_MSG_SIZE) {
491 async_answer_0(chandle, EINVAL);
492 async_answer_0(icall_handle, EINVAL);
493 return;
494 }
495
496 data = malloc(size);
497 if (data == NULL) {
498 async_answer_0(chandle, ENOMEM);
499 async_answer_0(icall_handle, ENOMEM);
500 }
501
502 rc = async_data_write_finalize(chandle, data, size);
503 if (rc != EOK) {
504 async_answer_0(chandle, rc);
505 async_answer_0(icall_handle, rc);
506 free(data);
507 return;
508 }
509
510 assoc_id = IPC_GET_ARG1(*icall);
511
512 rc = udp_assoc_send_msg_impl(client, assoc_id, &dest, data, size);
513 if (rc != EOK) {
514 async_answer_0(icall_handle, rc);
515 free(data);
516 return;
517 }
518
519 async_answer_0(icall_handle, EOK);
520 free(data);
521}
522
523/** Get next received message.
524 *
525 * @param client UDP Client
526 * @return Pointer to queue entry for next received message
527 */
528static udp_crcv_queue_entry_t *udp_rmsg_get_next(udp_client_t *client)
529{
530 link_t *link;
531
532 link = list_first(&client->crcv_queue);
533 if (link == NULL)
534 return NULL;
535
536 return list_get_instance(link, udp_crcv_queue_entry_t, link);
537}
538
539/** Get info on first received message.
540 *
541 * Handle client request to get information on received message.
542 *
543 * @param client UDP client
544 * @param iid Async request ID
545 * @param icall Async request data
546 */
547static void udp_rmsg_info_srv(udp_client_t *client, cap_call_handle_t icall_handle,
548 ipc_call_t *icall)
549{
550 cap_call_handle_t chandle;
551 size_t size;
552 udp_crcv_queue_entry_t *enext;
553 sysarg_t assoc_id;
554 errno_t rc;
555
556 log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_rmsg_info_srv()");
557 enext = udp_rmsg_get_next(client);
558
559 if (!async_data_read_receive(&chandle, &size)) {
560 async_answer_0(chandle, EREFUSED);
561 async_answer_0(icall_handle, EREFUSED);
562 return;
563 }
564
565 if (enext == NULL) {
566 async_answer_0(chandle, ENOENT);
567 async_answer_0(icall_handle, ENOENT);
568 return;
569 }
570
571 rc = async_data_read_finalize(chandle, &enext->epp.remote,
572 max(size, (size_t)sizeof(inet_ep_t)));
573 if (rc != EOK) {
574 async_answer_0(icall_handle, rc);
575 return;
576 }
577
578 assoc_id = enext->cassoc->id;
579 size = enext->msg->data_size;
580
581 log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_rmsg_info_srv(): assoc_id=%zu, "
582 "size=%zu", assoc_id, size);
583 async_answer_2(icall_handle, EOK, assoc_id, size);
584}
585
586/** Read data from first received message.
587 *
588 * Handle client request to read data from first received message.
589 *
590 * @param client UDP client
591 * @param iid Async request ID
592 * @param icall Async request data
593 */
594static void udp_rmsg_read_srv(udp_client_t *client, cap_call_handle_t icall_handle,
595 ipc_call_t *icall)
596{
597 cap_call_handle_t chandle;
598 size_t msg_size;
599 udp_crcv_queue_entry_t *enext;
600 void *data;
601 size_t size;
602 size_t off;
603 errno_t rc;
604
605 log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_rmsg_read_srv()");
606 off = IPC_GET_ARG1(*icall);
607
608 enext = udp_rmsg_get_next(client);
609
610 if (!async_data_read_receive(&chandle, &size)) {
611 async_answer_0(chandle, EREFUSED);
612 async_answer_0(icall_handle, EREFUSED);
613 return;
614 }
615
616 if (enext == NULL) {
617 async_answer_0(chandle, ENOENT);
618 async_answer_0(icall_handle, ENOENT);
619 return;
620 }
621
622 data = enext->msg->data + off;
623 msg_size = enext->msg->data_size;
624
625 if (off > msg_size) {
626 async_answer_0(chandle, EINVAL);
627 async_answer_0(icall_handle, EINVAL);
628 return;
629 }
630
631 rc = async_data_read_finalize(chandle, data, min(msg_size - off, size));
632 if (rc != EOK) {
633 async_answer_0(icall_handle, rc);
634 return;
635 }
636
637 async_answer_0(icall_handle, EOK);
638 log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_rmsg_read_srv(): OK");
639}
640
641/** Discard first received message.
642 *
643 * Handle client request to discard first received message, advancing
644 * to the next one.
645 *
646 * @param client UDP client
647 * @param iid Async request ID
648 * @param icall Async request data
649 */
650static void udp_rmsg_discard_srv(udp_client_t *client, cap_call_handle_t icall_handle,
651 ipc_call_t *icall)
652{
653 udp_crcv_queue_entry_t *enext;
654
655 log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_rmsg_discard_srv()");
656
657 enext = udp_rmsg_get_next(client);
658 if (enext == NULL) {
659 log_msg(LOG_DEFAULT, LVL_DEBUG, "usg_rmsg_discard_srv: enext==NULL");
660 async_answer_0(icall_handle, ENOENT);
661 return;
662 }
663
664 list_remove(&enext->link);
665 udp_msg_delete(enext->msg);
666 free(enext);
667 async_answer_0(icall_handle, EOK);
668}
669
670/** Handle UDP client connection.
671 *
672 * @param icall_handle Connect call handle
673 * @param icall Connect call data
674 * @param arg Connection argument
675 */
676static void udp_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall,
677 void *arg)
678{
679 udp_client_t client;
680 unsigned long n;
681
682 /* Accept the connection */
683 async_answer_0(icall_handle, EOK);
684
685 log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_client_conn()");
686
687 client.sess = NULL;
688 list_initialize(&client.cassoc);
689 list_initialize(&client.crcv_queue);
690
691 while (true) {
692 log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_client_conn: wait req");
693 ipc_call_t call;
694 cap_call_handle_t chandle = async_get_call(&call);
695 sysarg_t method = IPC_GET_IMETHOD(call);
696
697 log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_client_conn: method=%d",
698 (int)method);
699 if (!method) {
700 /* The other side has hung up */
701 async_answer_0(chandle, EOK);
702 break;
703 }
704
705 switch (method) {
706 case UDP_CALLBACK_CREATE:
707 udp_callback_create_srv(&client, chandle, &call);
708 break;
709 case UDP_ASSOC_CREATE:
710 udp_assoc_create_srv(&client, chandle, &call);
711 break;
712 case UDP_ASSOC_DESTROY:
713 udp_assoc_destroy_srv(&client, chandle, &call);
714 break;
715 case UDP_ASSOC_SET_NOLOCAL:
716 udp_assoc_set_nolocal_srv(&client, chandle, &call);
717 break;
718 case UDP_ASSOC_SEND_MSG:
719 udp_assoc_send_msg_srv(&client, chandle, &call);
720 break;
721 case UDP_RMSG_INFO:
722 udp_rmsg_info_srv(&client, chandle, &call);
723 break;
724 case UDP_RMSG_READ:
725 udp_rmsg_read_srv(&client, chandle, &call);
726 break;
727 case UDP_RMSG_DISCARD:
728 udp_rmsg_discard_srv(&client, chandle, &call);
729 break;
730 default:
731 async_answer_0(chandle, ENOTSUP);
732 break;
733 }
734 }
735
736 log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_client_conn: terminated");
737
738 n = list_count(&client.cassoc);
739 if (n != 0) {
740 log_msg(LOG_DEFAULT, LVL_WARN, "udp_client_conn: "
741 "Client with %lu active associations closed session.", n);
742 /* XXX Clean up */
743 }
744
745 /* XXX Clean up client receive queue */
746
747 if (client.sess != NULL)
748 async_hangup(client.sess);
749}
750
751/** Initialize UDP service.
752 *
753 * @return EOK on success or an error code.
754 */
755errno_t udp_service_init(void)
756{
757 errno_t rc;
758 service_id_t sid;
759
760 async_set_fallback_port_handler(udp_client_conn, NULL);
761
762 rc = loc_server_register(NAME);
763 if (rc != EOK) {
764 log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering server.");
765 return EIO;
766 }
767
768 rc = loc_service_register(SERVICE_NAME_UDP, &sid);
769 if (rc != EOK) {
770 log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering service.");
771 return EIO;
772 }
773
774 return EOK;
775}
776
777/**
778 * @}
779 */
Note: See TracBrowser for help on using the repository browser.