source: mainline/uspace/srv/net/tl/udp/udp.c@ a33f0a6

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since a33f0a6 was 6b82009, checked in by Martin Decky <martin@…>, 14 years ago

networking stack: convert to the new async framework
  • Property mode set to 100644
File size: 25.3 KB
Line 
1/*
2 * Copyright (c) 2008 Lukas Mejdrech
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/** @file
34 * UDP module implementation.
35 * @see udp.h
36 */
37
38#include <async.h>
39#include <fibril_synch.h>
40#include <malloc.h>
41#include <stdio.h>
42#include <ipc/services.h>
43#include <ipc/net.h>
44#include <ipc/tl.h>
45#include <ipc/socket.h>
46#include <adt/dynamic_fifo.h>
47#include <errno.h>
48
49#include <net/socket_codes.h>
50#include <net/ip_protocols.h>
51#include <net/in.h>
52#include <net/in6.h>
53#include <net/inet.h>
54#include <net/modules.h>
55
56#include <packet_client.h>
57#include <packet_remote.h>
58#include <net_checksum.h>
59#include <ip_client.h>
60#include <ip_interface.h>
61#include <icmp_client.h>
62#include <icmp_remote.h>
63#include <net_interface.h>
64#include <socket_core.h>
65#include <tl_common.h>
66#include <tl_remote.h>
67#include <tl_skel.h>
68
69#include "udp.h"
70#include "udp_header.h"
71
72/** UDP module name. */
73#define NAME "udp"
74
75/** Default UDP checksum computing. */
76#define NET_DEFAULT_UDP_CHECKSUM_COMPUTING true
77
78/** Default UDP autobind when sending via unbound sockets. */
79#define NET_DEFAULT_UDP_AUTOBINDING true
80
81/** Maximum UDP fragment size. */
82#define MAX_UDP_FRAGMENT_SIZE 65535
83
84/** Free ports pool start. */
85#define UDP_FREE_PORTS_START 1025
86
87/** Free ports pool end. */
88#define UDP_FREE_PORTS_END 65535
89
90/** UDP global data. */
91udp_globals_t udp_globals;
92
93/** Releases the packet and returns the result.
94 *
95 * @param[in] packet The packet queue to be released.
96 * @param[in] result The result to be returned.
97 * @return The result parameter.
98 */
99static int udp_release_and_return(packet_t *packet, int result)
100{
101 pq_release_remote(udp_globals.net_sess, packet_get_id(packet));
102 return result;
103}
104
105/** Processes the received UDP packet queue.
106 *
107 * Notifies the destination socket application.
108 * Releases the packet on error or sends an ICMP error notification.
109 *
110 * @param[in] device_id The receiving device identifier.
111 * @param[in,out] packet The received packet queue.
112 * @param[in] error The packet error reporting service. Prefixes the
113 * received packet.
114 * @return EOK on success.
115 * @return EINVAL if the packet is not valid.
116 * @return EINVAL if the stored packet address is not the
117 * an_addr_t.
118 * @return EINVAL if the packet does not contain any data.
119 * @return NO_DATA if the packet content is shorter than the user
120 * datagram header.
121 * @return ENOMEM if there is not enough memory left.
122 * @return EADDRNOTAVAIL if the destination socket does not exist.
123 * @return Other error codes as defined for the
124 * ip_client_process_packet() function.
125 */
126static int udp_process_packet(device_id_t device_id, packet_t *packet,
127 services_t error)
128{
129 size_t length;
130 size_t offset;
131 int result;
132 udp_header_t *header;
133 socket_core_t *socket;
134 packet_t *next_packet;
135 size_t total_length;
136 uint32_t checksum;
137 int fragments;
138 packet_t *tmp_packet;
139 icmp_type_t type;
140 icmp_code_t code;
141 void *ip_header;
142 struct sockaddr *src;
143 struct sockaddr *dest;
144 packet_dimension_t *packet_dimension;
145 int rc;
146
147 switch (error) {
148 case SERVICE_NONE:
149 break;
150 case SERVICE_ICMP:
151 /* Ignore error */
152 // length = icmp_client_header_length(packet);
153
154 /* Process error */
155 result = icmp_client_process_packet(packet, &type,
156 &code, NULL, NULL);
157 if (result < 0)
158 return udp_release_and_return(packet, result);
159 length = (size_t) result;
160 rc = packet_trim(packet, length, 0);
161 if (rc != EOK)
162 return udp_release_and_return(packet, rc);
163 break;
164 default:
165 return udp_release_and_return(packet, ENOTSUP);
166 }
167
168 /* TODO process received ipopts? */
169 result = ip_client_process_packet(packet, NULL, NULL, NULL, NULL, NULL);
170 if (result < 0)
171 return udp_release_and_return(packet, result);
172 offset = (size_t) result;
173
174 length = packet_get_data_length(packet);
175 if (length <= 0)
176 return udp_release_and_return(packet, EINVAL);
177 if (length < UDP_HEADER_SIZE + offset)
178 return udp_release_and_return(packet, NO_DATA);
179
180 /* Trim all but UDP header */
181 rc = packet_trim(packet, offset, 0);
182 if (rc != EOK)
183 return udp_release_and_return(packet, rc);
184
185 /* Get UDP header */
186 header = (udp_header_t *) packet_get_data(packet);
187 if (!header)
188 return udp_release_and_return(packet, NO_DATA);
189
190 /* Find the destination socket */
191 socket = socket_port_find(&udp_globals.sockets,
192 ntohs(header->destination_port), (uint8_t *) SOCKET_MAP_KEY_LISTENING, 0);
193 if (!socket) {
194 if (tl_prepare_icmp_packet(udp_globals.net_sess,
195 udp_globals.icmp_sess, packet, error) == EOK) {
196 icmp_destination_unreachable_msg(udp_globals.icmp_sess,
197 ICMP_PORT_UNREACH, 0, packet);
198 }
199 return EADDRNOTAVAIL;
200 }
201
202 /* Count the received packet fragments */
203 next_packet = packet;
204 fragments = 0;
205 total_length = ntohs(header->total_length);
206
207 /* Compute header checksum if set */
208 if (header->checksum && !error) {
209 result = packet_get_addr(packet, (uint8_t **) &src,
210 (uint8_t **) &dest);
211 if (result <= 0)
212 return udp_release_and_return(packet, result);
213
214 rc = ip_client_get_pseudo_header(IPPROTO_UDP, src, result, dest,
215 result, total_length, &ip_header, &length);
216 if (rc != EOK) {
217 return udp_release_and_return(packet, rc);
218 } else {
219 checksum = compute_checksum(0, ip_header, length);
220 /*
221 * The udp header checksum will be added with the first
222 * fragment later.
223 */
224 free(ip_header);
225 }
226 } else {
227 header->checksum = 0;
228 checksum = 0;
229 }
230
231 do {
232 fragments++;
233 length = packet_get_data_length(next_packet);
234 if (length <= 0)
235 return udp_release_and_return(packet, NO_DATA);
236
237 if (total_length < length) {
238 rc = packet_trim(next_packet, 0, length - total_length);
239 if (rc != EOK)
240 return udp_release_and_return(packet, rc);
241
242 /* Add partial checksum if set */
243 if (header->checksum) {
244 checksum = compute_checksum(checksum,
245 packet_get_data(packet),
246 packet_get_data_length(packet));
247 }
248
249 /* Relese the rest of the packet fragments */
250 tmp_packet = pq_next(next_packet);
251 while (tmp_packet) {
252 next_packet = pq_detach(tmp_packet);
253 pq_release_remote(udp_globals.net_sess,
254 packet_get_id(tmp_packet));
255 tmp_packet = next_packet;
256 }
257
258 /* Exit the loop */
259 break;
260 }
261 total_length -= length;
262
263 /* Add partial checksum if set */
264 if (header->checksum) {
265 checksum = compute_checksum(checksum,
266 packet_get_data(packet),
267 packet_get_data_length(packet));
268 }
269
270 } while ((next_packet = pq_next(next_packet)) && (total_length > 0));
271
272 /* Verify checksum */
273 if (header->checksum) {
274 if (flip_checksum(compact_checksum(checksum)) !=
275 IP_CHECKSUM_ZERO) {
276 if (tl_prepare_icmp_packet(udp_globals.net_sess,
277 udp_globals.icmp_sess, packet, error) == EOK) {
278 /* Checksum error ICMP */
279 icmp_parameter_problem_msg(
280 udp_globals.icmp_sess, ICMP_PARAM_POINTER,
281 ((size_t) ((void *) &header->checksum)) -
282 ((size_t) ((void *) header)), packet);
283 }
284 return EINVAL;
285 }
286 }
287
288 /* Queue the received packet */
289 rc = dyn_fifo_push(&socket->received, packet_get_id(packet),
290 SOCKET_MAX_RECEIVED_SIZE);
291 if (rc != EOK)
292 return udp_release_and_return(packet, rc);
293
294 rc = tl_get_ip_packet_dimension(udp_globals.ip_sess,
295 &udp_globals.dimensions, device_id, &packet_dimension);
296 if (rc != EOK)
297 return udp_release_and_return(packet, rc);
298
299 /* Notify the destination socket */
300 fibril_rwlock_write_unlock(&udp_globals.lock);
301
302 async_exch_t *exch = async_exchange_begin(socket->sess);
303 async_msg_5(exch, NET_SOCKET_RECEIVED, (sysarg_t) socket->socket_id,
304 packet_dimension->content, 0, 0, (sysarg_t) fragments);
305 async_exchange_end(exch);
306
307 return EOK;
308}
309
310/** Processes the received UDP packet queue.
311 *
312 * Is used as an entry point from the underlying IP module.
313 * Locks the global lock and calls udp_process_packet() function.
314 *
315 * @param[in] device_id The receiving device identifier.
316 * @param[in,out] packet The received packet queue.
317 * @param receiver The target service. Ignored parameter.
318 * @param[in] error The packet error reporting service. Prefixes the
319 * received packet.
320 * @return EOK on success.
321 * @return Other error codes as defined for the
322 * udp_process_packet() function.
323 */
324static int udp_received_msg(device_id_t device_id, packet_t *packet,
325 services_t receiver, services_t error)
326{
327 int result;
328
329 fibril_rwlock_write_lock(&udp_globals.lock);
330 result = udp_process_packet(device_id, packet, error);
331 if (result != EOK)
332 fibril_rwlock_write_unlock(&udp_globals.lock);
333
334 return result;
335}
336
337/** Process IPC messages from the IP module
338 *
339 * @param[in] iid Message identifier.
340 * @param[in,out] icall Message parameters.
341 * @param[in] arg Local argument.
342 *
343 */
344static void udp_receiver(ipc_callid_t iid, ipc_call_t *icall, void *arg)
345{
346 packet_t *packet;
347 int rc;
348
349 while (true) {
350 switch (IPC_GET_IMETHOD(*icall)) {
351 case NET_TL_RECEIVED:
352 rc = packet_translate_remote(udp_globals.net_sess, &packet,
353 IPC_GET_PACKET(*icall));
354 if (rc == EOK)
355 rc = udp_received_msg(IPC_GET_DEVICE(*icall), packet,
356 SERVICE_UDP, IPC_GET_ERROR(*icall));
357
358 async_answer_0(iid, (sysarg_t) rc);
359 break;
360 default:
361 async_answer_0(iid, (sysarg_t) ENOTSUP);
362 }
363
364 iid = async_get_call(icall);
365 }
366}
367
368/** Initialize the UDP module.
369 *
370 * @param[in] sess Network module session.
371 *
372 * @return EOK on success.
373 * @return ENOMEM if there is not enough memory left.
374 *
375 */
376int tl_initialize(async_sess_t *sess)
377{
378 measured_string_t names[] = {
379 {
380 (uint8_t *) "UDP_CHECKSUM_COMPUTING",
381 22
382 },
383 {
384 (uint8_t *) "UDP_AUTOBINDING",
385 15
386 }
387 };
388 measured_string_t *configuration;
389 size_t count = sizeof(names) / sizeof(measured_string_t);
390 uint8_t *data;
391
392 fibril_rwlock_initialize(&udp_globals.lock);
393 fibril_rwlock_write_lock(&udp_globals.lock);
394
395 udp_globals.net_sess = sess;
396 udp_globals.icmp_sess = icmp_connect_module();
397
398 udp_globals.ip_sess = ip_bind_service(SERVICE_IP, IPPROTO_UDP,
399 SERVICE_UDP, udp_receiver);
400 if (udp_globals.ip_sess == NULL) {
401 fibril_rwlock_write_unlock(&udp_globals.lock);
402 return ENOENT;
403 }
404
405 /* Read default packet dimensions */
406 int rc = ip_packet_size_req(udp_globals.ip_sess, -1,
407 &udp_globals.packet_dimension);
408 if (rc != EOK) {
409 fibril_rwlock_write_unlock(&udp_globals.lock);
410 return rc;
411 }
412
413 rc = socket_ports_initialize(&udp_globals.sockets);
414 if (rc != EOK) {
415 fibril_rwlock_write_unlock(&udp_globals.lock);
416 return rc;
417 }
418
419 rc = packet_dimensions_initialize(&udp_globals.dimensions);
420 if (rc != EOK) {
421 socket_ports_destroy(&udp_globals.sockets, free);
422 fibril_rwlock_write_unlock(&udp_globals.lock);
423 return rc;
424 }
425
426 udp_globals.packet_dimension.prefix += sizeof(udp_header_t);
427 udp_globals.packet_dimension.content -= sizeof(udp_header_t);
428 udp_globals.last_used_port = UDP_FREE_PORTS_START - 1;
429
430 udp_globals.checksum_computing = NET_DEFAULT_UDP_CHECKSUM_COMPUTING;
431 udp_globals.autobinding = NET_DEFAULT_UDP_AUTOBINDING;
432
433 /* Get configuration */
434 configuration = &names[0];
435 rc = net_get_conf_req(udp_globals.net_sess, &configuration, count,
436 &data);
437 if (rc != EOK) {
438 socket_ports_destroy(&udp_globals.sockets, free);
439 fibril_rwlock_write_unlock(&udp_globals.lock);
440 return rc;
441 }
442
443 if (configuration) {
444 if (configuration[0].value)
445 udp_globals.checksum_computing =
446 (configuration[0].value[0] == 'y');
447
448 if (configuration[1].value)
449 udp_globals.autobinding =
450 (configuration[1].value[0] == 'y');
451
452 net_free_settings(configuration, data);
453 }
454
455 fibril_rwlock_write_unlock(&udp_globals.lock);
456 return EOK;
457}
458
459/** Sends data from the socket to the remote address.
460 *
461 * Binds the socket to a free port if not already connected/bound.
462 * Handles the NET_SOCKET_SENDTO message.
463 * Supports AF_INET and AF_INET6 address families.
464 *
465 * @param[in,out] local_sockets The application local sockets.
466 * @param[in] socket_id Socket identifier.
467 * @param[in] addr The destination address.
468 * @param[in] addrlen The address length.
469 * @param[in] fragments The number of data fragments.
470 * @param[out] data_fragment_size The data fragment size in bytes.
471 * @param[in] flags Various send flags.
472 * @return EOK on success.
473 * @return EAFNOTSUPPORT if the address family is not supported.
474 * @return ENOTSOCK if the socket is not found.
475 * @return EINVAL if the address is invalid.
476 * @return ENOTCONN if the sending socket is not and cannot be
477 * bound.
478 * @return ENOMEM if there is not enough memory left.
479 * @return Other error codes as defined for the
480 * socket_read_packet_data() function.
481 * @return Other error codes as defined for the
482 * ip_client_prepare_packet() function.
483 * @return Other error codes as defined for the ip_send_msg()
484 * function.
485 */
486static int udp_sendto_message(socket_cores_t *local_sockets, int socket_id,
487 const struct sockaddr *addr, socklen_t addrlen, int fragments,
488 size_t *data_fragment_size, int flags)
489{
490 socket_core_t *socket;
491 packet_t *packet;
492 packet_t *next_packet;
493 udp_header_t *header;
494 int index;
495 size_t total_length;
496 int result;
497 uint16_t dest_port;
498 uint32_t checksum;
499 void *ip_header;
500 size_t headerlen;
501 device_id_t device_id;
502 packet_dimension_t *packet_dimension;
503 size_t size;
504 int rc;
505
506 /* In case of error, do not update the data fragment size. */
507 *data_fragment_size = 0;
508
509 rc = tl_get_address_port(addr, addrlen, &dest_port);
510 if (rc != EOK)
511 return rc;
512
513 socket = socket_cores_find(local_sockets, socket_id);
514 if (!socket)
515 return ENOTSOCK;
516
517 if ((socket->port <= 0) && udp_globals.autobinding) {
518 /* Bind the socket to a random free port if not bound */
519 rc = socket_bind_free_port(&udp_globals.sockets, socket,
520 UDP_FREE_PORTS_START, UDP_FREE_PORTS_END,
521 udp_globals.last_used_port);
522 if (rc != EOK)
523 return rc;
524 /* Set the next port as the search starting port number */
525 udp_globals.last_used_port = socket->port;
526 }
527
528 if (udp_globals.checksum_computing) {
529 rc = ip_get_route_req(udp_globals.ip_sess, IPPROTO_UDP, addr,
530 addrlen, &device_id, &ip_header, &headerlen);
531 if (rc != EOK)
532 return rc;
533 /* Get the device packet dimension */
534// rc = tl_get_ip_packet_dimension(udp_globals.ip_sess,
535// &udp_globals.dimensions, device_id, &packet_dimension);
536// if (rc != EOK)
537// return rc;
538 }
539// } else {
540 /* Do not ask all the time */
541 rc = ip_packet_size_req(udp_globals.ip_sess, -1,
542 &udp_globals.packet_dimension);
543 if (rc != EOK)
544 return rc;
545 packet_dimension = &udp_globals.packet_dimension;
546// }
547
548 /*
549 * Update the data fragment size based on what the lower layers can
550 * handle without fragmentation, but not more than the maximum allowed
551 * for UDP.
552 */
553 size = MAX_UDP_FRAGMENT_SIZE;
554 if (packet_dimension->content < size)
555 size = packet_dimension->content;
556 *data_fragment_size = size;
557
558 /* Read the first packet fragment */
559 result = tl_socket_read_packet_data(udp_globals.net_sess, &packet,
560 UDP_HEADER_SIZE, packet_dimension, addr, addrlen);
561 if (result < 0)
562 return result;
563
564 total_length = (size_t) result;
565 if (udp_globals.checksum_computing)
566 checksum = compute_checksum(0, packet_get_data(packet),
567 packet_get_data_length(packet));
568 else
569 checksum = 0;
570
571 /* Prefix the UDP header */
572 header = PACKET_PREFIX(packet, udp_header_t);
573 if (!header)
574 return udp_release_and_return(packet, ENOMEM);
575
576 bzero(header, sizeof(*header));
577
578 /* Read the rest of the packet fragments */
579 for (index = 1; index < fragments; index++) {
580 result = tl_socket_read_packet_data(udp_globals.net_sess,
581 &next_packet, 0, packet_dimension, addr, addrlen);
582 if (result < 0)
583 return udp_release_and_return(packet, result);
584
585 rc = pq_add(&packet, next_packet, index, 0);
586 if (rc != EOK)
587 return udp_release_and_return(packet, rc);
588
589 total_length += (size_t) result;
590 if (udp_globals.checksum_computing) {
591 checksum = compute_checksum(checksum,
592 packet_get_data(next_packet),
593 packet_get_data_length(next_packet));
594 }
595 }
596
597 /* Set the UDP header */
598 header->source_port = htons((socket->port > 0) ? socket->port : 0);
599 header->destination_port = htons(dest_port);
600 header->total_length = htons(total_length + sizeof(*header));
601 header->checksum = 0;
602
603 if (udp_globals.checksum_computing) {
604 /* Update the pseudo header */
605 rc = ip_client_set_pseudo_header_data_length(ip_header,
606 headerlen, total_length + UDP_HEADER_SIZE);
607 if (rc != EOK) {
608 free(ip_header);
609 return udp_release_and_return(packet, rc);
610 }
611
612 /* Finish the checksum computation */
613 checksum = compute_checksum(checksum, ip_header, headerlen);
614 checksum = compute_checksum(checksum, (uint8_t *) header,
615 sizeof(*header));
616 header->checksum =
617 htons(flip_checksum(compact_checksum(checksum)));
618 free(ip_header);
619 } else {
620 device_id = DEVICE_INVALID_ID;
621 }
622
623 /* Prepare the first packet fragment */
624 rc = ip_client_prepare_packet(packet, IPPROTO_UDP, 0, 0, 0, 0);
625 if (rc != EOK)
626 return udp_release_and_return(packet, rc);
627
628 /* Release the UDP global lock on success. */
629 fibril_rwlock_write_unlock(&udp_globals.lock);
630
631 /* Send the packet */
632 ip_send_msg(udp_globals.ip_sess, device_id, packet, SERVICE_UDP, 0);
633
634 return EOK;
635}
636
637/** Receives data to the socket.
638 *
639 * Handles the NET_SOCKET_RECVFROM message.
640 * Replies the source address as well.
641 *
642 * @param[in] local_sockets The application local sockets.
643 * @param[in] socket_id Socket identifier.
644 * @param[in] flags Various receive flags.
645 * @param[out] addrlen The source address length.
646 * @return The number of bytes received.
647 * @return ENOTSOCK if the socket is not found.
648 * @return NO_DATA if there are no received packets or data.
649 * @return ENOMEM if there is not enough memory left.
650 * @return EINVAL if the received address is not an IP address.
651 * @return Other error codes as defined for the packet_translate()
652 * function.
653 * @return Other error codes as defined for the data_reply()
654 * function.
655 */
656static int udp_recvfrom_message(socket_cores_t *local_sockets, int socket_id,
657 int flags, size_t *addrlen)
658{
659 socket_core_t *socket;
660 int packet_id;
661 packet_t *packet;
662 udp_header_t *header;
663 struct sockaddr *addr;
664 size_t length;
665 uint8_t *data;
666 int result;
667 int rc;
668
669 /* Find the socket */
670 socket = socket_cores_find(local_sockets, socket_id);
671 if (!socket)
672 return ENOTSOCK;
673
674 /* Get the next received packet */
675 packet_id = dyn_fifo_value(&socket->received);
676 if (packet_id < 0)
677 return NO_DATA;
678
679 rc = packet_translate_remote(udp_globals.net_sess, &packet, packet_id);
680 if (rc != EOK) {
681 (void) dyn_fifo_pop(&socket->received);
682 return rc;
683 }
684
685 /* Get UDP header */
686 data = packet_get_data(packet);
687 if (!data) {
688 (void) dyn_fifo_pop(&socket->received);
689 return udp_release_and_return(packet, NO_DATA);
690 }
691 header = (udp_header_t *) data;
692
693 /* Set the source address port */
694 result = packet_get_addr(packet, (uint8_t **) &addr, NULL);
695 rc = tl_set_address_port(addr, result, ntohs(header->source_port));
696 if (rc != EOK) {
697 (void) dyn_fifo_pop(&socket->received);
698 return udp_release_and_return(packet, rc);
699 }
700 *addrlen = (size_t) result;
701
702 /* Send the source address */
703 rc = data_reply(addr, *addrlen);
704 switch (rc) {
705 case EOK:
706 break;
707 case EOVERFLOW:
708 return rc;
709 default:
710 (void) dyn_fifo_pop(&socket->received);
711 return udp_release_and_return(packet, rc);
712 }
713
714 /* Trim the header */
715 rc = packet_trim(packet, UDP_HEADER_SIZE, 0);
716 if (rc != EOK) {
717 (void) dyn_fifo_pop(&socket->received);
718 return udp_release_and_return(packet, rc);
719 }
720
721 /* Reply the packets */
722 rc = socket_reply_packets(packet, &length);
723 switch (rc) {
724 case EOK:
725 break;
726 case EOVERFLOW:
727 return rc;
728 default:
729 (void) dyn_fifo_pop(&socket->received);
730 return udp_release_and_return(packet, rc);
731 }
732
733 (void) dyn_fifo_pop(&socket->received);
734
735 /* Release the packet and return the total length */
736 return udp_release_and_return(packet, (int) length);
737}
738
739/** Process the socket client messages.
740 *
741 * Run until the client module disconnects.
742 *
743 * @see socket.h
744 *
745 * @param[in] sess Callback session.
746 * @param[in] callid Message identifier.
747 * @param[in] call Message parameters.
748 *
749 * @return EOK on success.
750 *
751 */
752static int udp_process_client_messages(async_sess_t *sess, ipc_callid_t callid,
753 ipc_call_t call)
754{
755 int res;
756 socket_cores_t local_sockets;
757 struct sockaddr *addr;
758 int socket_id;
759 size_t addrlen;
760 size_t size;
761 ipc_call_t answer;
762 size_t answer_count;
763 packet_dimension_t *packet_dimension;
764
765 /*
766 * Accept the connection
767 * - Answer the first IPC_M_CONNECT_TO_ME call.
768 */
769 res = EOK;
770 answer_count = 0;
771
772 /*
773 * The client connection is only in one fibril and therefore no
774 * additional locks are needed.
775 */
776
777 socket_cores_initialize(&local_sockets);
778
779 while (true) {
780
781 /* Answer the call */
782 answer_call(callid, res, &answer, answer_count);
783
784 /* Refresh data */
785 refresh_answer(&answer, &answer_count);
786
787 /* Get the next call */
788 callid = async_get_call(&call);
789
790 /* Process the call */
791 if (!IPC_GET_IMETHOD(call)) {
792 res = EHANGUP;
793 break;
794 }
795
796 switch (IPC_GET_IMETHOD(call)) {
797 case NET_SOCKET:
798 socket_id = SOCKET_GET_SOCKET_ID(call);
799 res = socket_create(&local_sockets, sess, NULL,
800 &socket_id);
801 SOCKET_SET_SOCKET_ID(answer, socket_id);
802
803 if (res != EOK)
804 break;
805
806 size = MAX_UDP_FRAGMENT_SIZE;
807 if (tl_get_ip_packet_dimension(udp_globals.ip_sess,
808 &udp_globals.dimensions, DEVICE_INVALID_ID,
809 &packet_dimension) == EOK) {
810 if (packet_dimension->content < size)
811 size = packet_dimension->content;
812 }
813 SOCKET_SET_DATA_FRAGMENT_SIZE(answer, size);
814 SOCKET_SET_HEADER_SIZE(answer, UDP_HEADER_SIZE);
815 answer_count = 3;
816 break;
817
818 case NET_SOCKET_BIND:
819 res = async_data_write_accept((void **) &addr, false,
820 0, 0, 0, &addrlen);
821 if (res != EOK)
822 break;
823 fibril_rwlock_write_lock(&udp_globals.lock);
824 res = socket_bind(&local_sockets, &udp_globals.sockets,
825 SOCKET_GET_SOCKET_ID(call), addr, addrlen,
826 UDP_FREE_PORTS_START, UDP_FREE_PORTS_END,
827 udp_globals.last_used_port);
828 fibril_rwlock_write_unlock(&udp_globals.lock);
829 free(addr);
830 break;
831
832 case NET_SOCKET_SENDTO:
833 res = async_data_write_accept((void **) &addr, false,
834 0, 0, 0, &addrlen);
835 if (res != EOK)
836 break;
837
838 fibril_rwlock_write_lock(&udp_globals.lock);
839 res = udp_sendto_message(&local_sockets,
840 SOCKET_GET_SOCKET_ID(call), addr, addrlen,
841 SOCKET_GET_DATA_FRAGMENTS(call), &size,
842 SOCKET_GET_FLAGS(call));
843 SOCKET_SET_DATA_FRAGMENT_SIZE(answer, size);
844
845 if (res != EOK)
846 fibril_rwlock_write_unlock(&udp_globals.lock);
847 else
848 answer_count = 2;
849
850 free(addr);
851 break;
852
853 case NET_SOCKET_RECVFROM:
854 fibril_rwlock_write_lock(&udp_globals.lock);
855 res = udp_recvfrom_message(&local_sockets,
856 SOCKET_GET_SOCKET_ID(call), SOCKET_GET_FLAGS(call),
857 &addrlen);
858 fibril_rwlock_write_unlock(&udp_globals.lock);
859
860 if (res <= 0)
861 break;
862
863 SOCKET_SET_READ_DATA_LENGTH(answer, res);
864 SOCKET_SET_ADDRESS_LENGTH(answer, addrlen);
865 answer_count = 3;
866 res = EOK;
867 break;
868
869 case NET_SOCKET_CLOSE:
870 fibril_rwlock_write_lock(&udp_globals.lock);
871 res = socket_destroy(udp_globals.net_sess,
872 SOCKET_GET_SOCKET_ID(call), &local_sockets,
873 &udp_globals.sockets, NULL);
874 fibril_rwlock_write_unlock(&udp_globals.lock);
875 break;
876
877 case NET_SOCKET_GETSOCKOPT:
878 case NET_SOCKET_SETSOCKOPT:
879 default:
880 res = ENOTSUP;
881 break;
882 }
883 }
884
885 /* Release the application session */
886 async_hangup(sess);
887
888 /* Release all local sockets */
889 socket_cores_release(udp_globals.net_sess, &local_sockets,
890 &udp_globals.sockets, NULL);
891
892 return res;
893}
894
895/** Per-connection initialization
896 *
897 */
898void tl_connection(void)
899{
900}
901
902/** Processes the UDP message.
903 *
904 * @param[in] callid The message identifier.
905 * @param[in] call The message parameters.
906 * @param[out] answer The message answer parameters.
907 * @param[out] answer_count The last parameter for the actual answer in the
908 * answer parameter.
909 * @return EOK on success.
910 * @return ENOTSUP if the message is not known.
911 *
912 * @see udp_interface.h
913 * @see IS_NET_UDP_MESSAGE()
914 */
915int tl_message(ipc_callid_t callid, ipc_call_t *call,
916 ipc_call_t *answer, size_t *answer_count)
917{
918 *answer_count = 0;
919
920 async_sess_t *callback =
921 async_callback_receive_start(EXCHANGE_SERIALIZE, call);
922 if (callback)
923 return udp_process_client_messages(callback, callid, *call);
924
925 return ENOTSUP;
926}
927
928int main(int argc, char *argv[])
929{
930 /* Start the module */
931 return tl_module_start(SERVICE_UDP);
932}
933
934/** @}
935 */
Note: See TracBrowser for help on using the repository browser.