source: mainline/uspace/srv/net/nil/eth/eth.c@ 5fe7692

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 5fe7692 was 5fe7692, checked in by Petr Koupy <petr.koupy@…>, 14 years ago

Removed side effects from map ADTs.
  • Property mode set to 100644
File size: 24.2 KB
Line 
1/*
2 * Copyright (c) 2009 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 eth
30 * @{
31 */
32
33/** @file
34 * Ethernet module implementation.
35 * @see eth.h
36 */
37
38#include <async.h>
39#include <malloc.h>
40#include <mem.h>
41#include <stdio.h>
42#include <byteorder.h>
43#include <str.h>
44#include <errno.h>
45#include <ipc/nil.h>
46#include <ipc/net.h>
47#include <ipc/services.h>
48#include <net/modules.h>
49#include <net_checksum.h>
50#include <ethernet_lsap.h>
51#include <ethernet_protocols.h>
52#include <protocol_map.h>
53#include <net/device.h>
54#include <netif_remote.h>
55#include <net_interface.h>
56#include <il_remote.h>
57#include <adt/measured_strings.h>
58#include <packet_client.h>
59#include <packet_remote.h>
60#include <nil_skel.h>
61
62#include "eth.h"
63
64/** The module name. */
65#define NAME "eth"
66
67/** Reserved packet prefix length. */
68#define ETH_PREFIX \
69 (sizeof(eth_header_t) + sizeof(eth_header_lsap_t) + \
70 sizeof(eth_header_snap_t))
71
72/** Reserved packet suffix length. */
73#define ETH_SUFFIX (sizeof(eth_fcs_t))
74
75/** Maximum packet content length. */
76#define ETH_MAX_CONTENT 1500u
77
78/** Minimum packet content length. */
79#define ETH_MIN_CONTENT 46u
80
81/** Maximum tagged packet content length. */
82#define ETH_MAX_TAGGED_CONTENT(flags) \
83 (ETH_MAX_CONTENT - \
84 ((IS_8023_2_LSAP(flags) || IS_8023_2_SNAP(flags)) ? \
85 sizeof(eth_header_lsap_t) : 0) - \
86 (IS_8023_2_SNAP(flags) ? sizeof(eth_header_snap_t) : 0))
87
88/** Minimum tagged packet content length. */
89#define ETH_MIN_TAGGED_CONTENT(flags) \
90 (ETH_MIN_CONTENT - \
91 ((IS_8023_2_LSAP(flags) || IS_8023_2_SNAP(flags)) ? \
92 sizeof(eth_header_lsap_t) : 0) - \
93 (IS_8023_2_SNAP(flags) ? sizeof(eth_header_snap_t) : 0))
94
95/** Dummy flag shift value. */
96#define ETH_DUMMY_SHIFT 0
97
98/** Mode flag shift value. */
99#define ETH_MODE_SHIFT 1
100
101/** Dummy device flag.
102 * Preamble and FCS are mandatory part of the packets.
103 */
104#define ETH_DUMMY (1 << ETH_DUMMY_SHIFT)
105
106/** Returns the dummy flag.
107 * @see ETH_DUMMY
108 */
109#define IS_DUMMY(flags) ((flags) & ETH_DUMMY)
110
111/** Device mode flags.
112 * @see ETH_DIX
113 * @see ETH_8023_2_LSAP
114 * @see ETH_8023_2_SNAP
115 */
116#define ETH_MODE_MASK (3 << ETH_MODE_SHIFT)
117
118/** DIX Ethernet mode flag. */
119#define ETH_DIX (1 << ETH_MODE_SHIFT)
120
121/** Return whether the DIX Ethernet mode flag is set.
122 *
123 * @param[in] flags Ethernet flags.
124 * @see ETH_DIX
125 *
126 */
127#define IS_DIX(flags) (((flags) & ETH_MODE_MASK) == ETH_DIX)
128
129/** 802.3 + 802.2 + LSAP mode flag. */
130#define ETH_8023_2_LSAP (2 << ETH_MODE_SHIFT)
131
132/** Return whether the 802.3 + 802.2 + LSAP mode flag is set.
133 *
134 * @param[in] flags Ethernet flags.
135 * @see ETH_8023_2_LSAP
136 *
137 */
138#define IS_8023_2_LSAP(flags) (((flags) & ETH_MODE_MASK) == ETH_8023_2_LSAP)
139
140/** 802.3 + 802.2 + LSAP + SNAP mode flag. */
141#define ETH_8023_2_SNAP (3 << ETH_MODE_SHIFT)
142
143/** Return whether the 802.3 + 802.2 + LSAP + SNAP mode flag is set.
144 *
145 * @param[in] flags Ethernet flags.
146 * @see ETH_8023_2_SNAP
147 *
148 */
149#define IS_8023_2_SNAP(flags) (((flags) & ETH_MODE_MASK) == ETH_8023_2_SNAP)
150
151/** Type definition of the ethernet address type.
152 * @see eth_addr_type
153 */
154typedef enum eth_addr_type eth_addr_type_t;
155
156/** Ethernet address type. */
157enum eth_addr_type {
158 /** Local address. */
159 ETH_LOCAL_ADDR,
160 /** Broadcast address. */
161 ETH_BROADCAST_ADDR
162};
163
164/** Ethernet module global data. */
165eth_globals_t eth_globals;
166
167DEVICE_MAP_IMPLEMENT(eth_devices, eth_device_t);
168INT_MAP_IMPLEMENT(eth_protos, eth_proto_t);
169
170int nil_device_state_msg_local(int nil_phone, device_id_t device_id, int state)
171{
172 int index;
173 eth_proto_t *proto;
174
175 fibril_rwlock_read_lock(&eth_globals.protos_lock);
176 for (index = eth_protos_count(&eth_globals.protos) - 1; index >= 0;
177 index--) {
178 proto = eth_protos_get_index(&eth_globals.protos, index);
179 if (proto && proto->phone) {
180 il_device_state_msg(proto->phone, device_id, state,
181 proto->service);
182 }
183 }
184 fibril_rwlock_read_unlock(&eth_globals.protos_lock);
185
186 return EOK;
187}
188
189int nil_initialize(int net_phone)
190{
191 int rc;
192
193 fibril_rwlock_initialize(&eth_globals.devices_lock);
194 fibril_rwlock_initialize(&eth_globals.protos_lock);
195
196 fibril_rwlock_write_lock(&eth_globals.devices_lock);
197 fibril_rwlock_write_lock(&eth_globals.protos_lock);
198 eth_globals.net_phone = net_phone;
199
200 eth_globals.broadcast_addr =
201 measured_string_create_bulk((uint8_t *) "\xFF\xFF\xFF\xFF\xFF\xFF", ETH_ADDR);
202 if (!eth_globals.broadcast_addr) {
203 rc = ENOMEM;
204 goto out;
205 }
206
207 rc = eth_devices_initialize(&eth_globals.devices);
208 if (rc != EOK) {
209 free(eth_globals.broadcast_addr);
210 goto out;
211 }
212
213 rc = eth_protos_initialize(&eth_globals.protos);
214 if (rc != EOK) {
215 free(eth_globals.broadcast_addr);
216 eth_devices_destroy(&eth_globals.devices, free);
217 }
218out:
219 fibril_rwlock_write_unlock(&eth_globals.protos_lock);
220 fibril_rwlock_write_unlock(&eth_globals.devices_lock);
221
222 return rc;
223}
224
225/** Processes IPC messages from the registered device driver modules in an
226 * infinite loop.
227 *
228 * @param[in] iid The message identifier.
229 * @param[in,out] icall The message parameters.
230 */
231static void eth_receiver(ipc_callid_t iid, ipc_call_t *icall)
232{
233 packet_t *packet;
234 int rc;
235
236 while (true) {
237 switch (IPC_GET_IMETHOD(*icall)) {
238 case NET_NIL_DEVICE_STATE:
239 nil_device_state_msg_local(0, IPC_GET_DEVICE(*icall),
240 IPC_GET_STATE(*icall));
241 async_answer_0(iid, EOK);
242 break;
243 case NET_NIL_RECEIVED:
244 rc = packet_translate_remote(eth_globals.net_phone,
245 &packet, IPC_GET_PACKET(*icall));
246 if (rc == EOK)
247 rc = nil_received_msg_local(0,
248 IPC_GET_DEVICE(*icall), packet, 0);
249
250 async_answer_0(iid, (sysarg_t) rc);
251 break;
252 default:
253 async_answer_0(iid, (sysarg_t) ENOTSUP);
254 }
255
256 iid = async_get_call(icall);
257 }
258}
259
260/** Registers new device or updates the MTU of an existing one.
261 *
262 * Determines the device local hardware address.
263 *
264 * @param[in] device_id The new device identifier.
265 * @param[in] service The device driver service.
266 * @param[in] mtu The device maximum transmission unit.
267 * @return EOK on success.
268 * @return EEXIST if the device with the different service exists.
269 * @return ENOMEM if there is not enough memory left.
270 * @return Other error codes as defined for the
271 * net_get_device_conf_req() function.
272 * @return Other error codes as defined for the
273 * netif_bind_service() function.
274 * @return Other error codes as defined for the
275 * netif_get_addr_req() function.
276 */
277static int eth_device_message(device_id_t device_id, services_t service,
278 size_t mtu)
279{
280 eth_device_t *device;
281 int index;
282 measured_string_t names[2] = {
283 {
284 (uint8_t *) "ETH_MODE",
285 8
286 },
287 {
288 (uint8_t *) "ETH_DUMMY",
289 9
290 }
291 };
292 measured_string_t *configuration;
293 size_t count = sizeof(names) / sizeof(measured_string_t);
294 uint8_t *data;
295 eth_proto_t *proto;
296 int rc;
297
298 fibril_rwlock_write_lock(&eth_globals.devices_lock);
299 /* An existing device? */
300 device = eth_devices_find(&eth_globals.devices, device_id);
301 if (device) {
302 if (device->service != service) {
303 printf("Device %d already exists\n", device->device_id);
304 fibril_rwlock_write_unlock(&eth_globals.devices_lock);
305 return EEXIST;
306 }
307
308 /* Update mtu */
309 if ((mtu > 0) && (mtu <= ETH_MAX_TAGGED_CONTENT(device->flags)))
310 device->mtu = mtu;
311 else
312 device->mtu = ETH_MAX_TAGGED_CONTENT(device->flags);
313
314 printf("Device %d already exists:\tMTU\t= %zu\n",
315 device->device_id, device->mtu);
316 fibril_rwlock_write_unlock(&eth_globals.devices_lock);
317
318 /* Notify all upper layer modules */
319 fibril_rwlock_read_lock(&eth_globals.protos_lock);
320 for (index = 0; index < eth_protos_count(&eth_globals.protos);
321 index++) {
322 proto = eth_protos_get_index(&eth_globals.protos,
323 index);
324 if (proto->phone) {
325 il_mtu_changed_msg(proto->phone,
326 device->device_id, device->mtu,
327 proto->service);
328 }
329 }
330
331 fibril_rwlock_read_unlock(&eth_globals.protos_lock);
332 return EOK;
333 }
334
335 /* Create a new device */
336 device = (eth_device_t *) malloc(sizeof(eth_device_t));
337 if (!device)
338 return ENOMEM;
339
340 device->device_id = device_id;
341 device->service = service;
342 device->flags = 0;
343 if ((mtu > 0) && (mtu <= ETH_MAX_TAGGED_CONTENT(device->flags)))
344 device->mtu = mtu;
345 else
346 device->mtu = ETH_MAX_TAGGED_CONTENT(device->flags);
347
348 configuration = &names[0];
349 rc = net_get_device_conf_req(eth_globals.net_phone, device->device_id,
350 &configuration, count, &data);
351 if (rc != EOK) {
352 fibril_rwlock_write_unlock(&eth_globals.devices_lock);
353 free(device);
354 return rc;
355 }
356
357 if (configuration) {
358 if (!str_lcmp((char *) configuration[0].value, "DIX",
359 configuration[0].length)) {
360 device->flags |= ETH_DIX;
361 } else if(!str_lcmp((char *) configuration[0].value, "8023_2_LSAP",
362 configuration[0].length)) {
363 device->flags |= ETH_8023_2_LSAP;
364 } else {
365 device->flags |= ETH_8023_2_SNAP;
366 }
367
368 if (configuration[1].value &&
369 (configuration[1].value[0] == 'y')) {
370 device->flags |= ETH_DUMMY;
371 }
372 net_free_settings(configuration, data);
373 } else {
374 device->flags |= ETH_8023_2_SNAP;
375 }
376
377 /* Bind the device driver */
378 device->phone = netif_bind_service(device->service, device->device_id,
379 SERVICE_ETHERNET, eth_receiver);
380 if (device->phone < 0) {
381 fibril_rwlock_write_unlock(&eth_globals.devices_lock);
382 free(device);
383 return device->phone;
384 }
385
386 /* Get hardware address */
387 rc = netif_get_addr_req(device->phone, device->device_id, &device->addr,
388 &device->addr_data);
389 if (rc != EOK) {
390 fibril_rwlock_write_unlock(&eth_globals.devices_lock);
391 free(device);
392 return rc;
393 }
394
395 /* Add to the cache */
396 index = eth_devices_add(&eth_globals.devices, device->device_id,
397 device);
398 if (index < 0) {
399 fibril_rwlock_write_unlock(&eth_globals.devices_lock);
400 free(device->addr);
401 free(device->addr_data);
402 free(device);
403 return index;
404 }
405
406 printf("%s: Device registered (id: %d, service: %d: mtu: %zu, "
407 "mac: %02x:%02x:%02x:%02x:%02x:%02x, flags: 0x%x)\n",
408 NAME, device->device_id, device->service, device->mtu,
409 device->addr_data[0], device->addr_data[1],
410 device->addr_data[2], device->addr_data[3],
411 device->addr_data[4], device->addr_data[5], device->flags);
412
413 fibril_rwlock_write_unlock(&eth_globals.devices_lock);
414 return EOK;
415}
416
417/** Processes the received packet and chooses the target registered module.
418 *
419 * @param[in] flags The device flags.
420 * @param[in] packet The packet.
421 * @return The target registered module.
422 * @return NULL if the packet is not long enough.
423 * @return NULL if the packet is too long.
424 * @return NULL if the raw ethernet protocol is used.
425 * @return NULL if the dummy device FCS checksum is invalid.
426 * @return NULL if the packet address length is not big enough.
427 */
428static eth_proto_t *eth_process_packet(int flags, packet_t *packet)
429{
430 eth_header_snap_t *header;
431 size_t length;
432 eth_type_t type;
433 size_t prefix;
434 size_t suffix;
435 eth_fcs_t *fcs;
436 uint8_t *data;
437 int rc;
438
439 length = packet_get_data_length(packet);
440
441 if (IS_DUMMY(flags))
442 packet_trim(packet, sizeof(eth_preamble_t), 0);
443 if (length < sizeof(eth_header_t) + ETH_MIN_CONTENT +
444 (IS_DUMMY(flags) ? ETH_SUFFIX : 0))
445 return NULL;
446
447 data = packet_get_data(packet);
448 header = (eth_header_snap_t *) data;
449 type = ntohs(header->header.ethertype);
450
451 if (type >= ETH_MIN_PROTO) {
452 /* DIX Ethernet */
453 prefix = sizeof(eth_header_t);
454 suffix = 0;
455 fcs = (eth_fcs_t *) data + length - sizeof(eth_fcs_t);
456 length -= sizeof(eth_fcs_t);
457 } else if(type <= ETH_MAX_CONTENT) {
458 /* Translate "LSAP" values */
459 if ((header->lsap.dsap == ETH_LSAP_GLSAP) &&
460 (header->lsap.ssap == ETH_LSAP_GLSAP)) {
461 /* Raw packet -- discard */
462 return NULL;
463 } else if((header->lsap.dsap == ETH_LSAP_SNAP) &&
464 (header->lsap.ssap == ETH_LSAP_SNAP)) {
465 /*
466 * IEEE 802.3 + 802.2 + LSAP + SNAP
467 * organization code not supported
468 */
469 type = ntohs(header->snap.ethertype);
470 prefix = sizeof(eth_header_t) +
471 sizeof(eth_header_lsap_t) +
472 sizeof(eth_header_snap_t);
473 } else {
474 /* IEEE 802.3 + 802.2 LSAP */
475 type = lsap_map(header->lsap.dsap);
476 prefix = sizeof(eth_header_t) +
477 sizeof(eth_header_lsap_t);
478 }
479
480 suffix = (type < ETH_MIN_CONTENT) ? ETH_MIN_CONTENT - type : 0U;
481 fcs = (eth_fcs_t *) data + prefix + type + suffix;
482 suffix += length - prefix - type;
483 length = prefix + type + suffix;
484 } else {
485 /* Invalid length/type, should not occur */
486 return NULL;
487 }
488
489 if (IS_DUMMY(flags)) {
490 if (~compute_crc32(~0U, data, length * 8) != ntohl(*fcs))
491 return NULL;
492 suffix += sizeof(eth_fcs_t);
493 }
494
495 rc = packet_set_addr(packet, header->header.source_address,
496 header->header.destination_address, ETH_ADDR);
497 if (rc != EOK)
498 return NULL;
499
500 rc = packet_trim(packet, prefix, suffix);
501 if (rc != EOK)
502 return NULL;
503
504 return eth_protos_find(&eth_globals.protos, type);
505}
506
507int nil_received_msg_local(int nil_phone, device_id_t device_id,
508 packet_t *packet, services_t target)
509{
510 eth_proto_t *proto;
511 packet_t *next;
512 eth_device_t *device;
513 int flags;
514
515 fibril_rwlock_read_lock(&eth_globals.devices_lock);
516 device = eth_devices_find(&eth_globals.devices, device_id);
517 if (!device) {
518 fibril_rwlock_read_unlock(&eth_globals.devices_lock);
519 return ENOENT;
520 }
521
522 flags = device->flags;
523 fibril_rwlock_read_unlock(&eth_globals.devices_lock);
524
525 fibril_rwlock_read_lock(&eth_globals.protos_lock);
526 do {
527 next = pq_detach(packet);
528 proto = eth_process_packet(flags, packet);
529 if (proto) {
530 il_received_msg(proto->phone, device_id, packet,
531 proto->service);
532 } else {
533 // drop invalid/unknown
534 pq_release_remote(eth_globals.net_phone,
535 packet_get_id(packet));
536 }
537 packet = next;
538 } while(packet);
539
540 fibril_rwlock_read_unlock(&eth_globals.protos_lock);
541 return EOK;
542}
543
544/** Returns the device packet dimensions for sending.
545 *
546 * @param[in] device_id The device identifier.
547 * @param[out] addr_len The minimum reserved address length.
548 * @param[out] prefix The minimum reserved prefix size.
549 * @param[out] content The maximum content size.
550 * @param[out] suffix The minimum reserved suffix size.
551 * @return EOK on success.
552 * @return EBADMEM if either one of the parameters is NULL.
553 * @return ENOENT if there is no such device.
554 */
555static int eth_packet_space_message(device_id_t device_id, size_t *addr_len,
556 size_t *prefix, size_t *content, size_t *suffix)
557{
558 eth_device_t *device;
559
560 if (!addr_len || !prefix || !content || !suffix)
561 return EBADMEM;
562
563 fibril_rwlock_read_lock(&eth_globals.devices_lock);
564 device = eth_devices_find(&eth_globals.devices, device_id);
565 if (!device) {
566 fibril_rwlock_read_unlock(&eth_globals.devices_lock);
567 return ENOENT;
568 }
569
570 *content = device->mtu;
571 fibril_rwlock_read_unlock(&eth_globals.devices_lock);
572
573 *addr_len = ETH_ADDR;
574 *prefix = ETH_PREFIX;
575 *suffix = ETH_MIN_CONTENT + ETH_SUFFIX;
576
577 return EOK;
578}
579
580/** Returns the device hardware address.
581 *
582 * @param[in] device_id The device identifier.
583 * @param[in] type Type of the desired address.
584 * @param[out] address The device hardware address.
585 * @return EOK on success.
586 * @return EBADMEM if the address parameter is NULL.
587 * @return ENOENT if there no such device.
588 */
589static int eth_addr_message(device_id_t device_id, eth_addr_type_t type,
590 measured_string_t **address)
591{
592 eth_device_t *device;
593
594 if (!address)
595 return EBADMEM;
596
597 if (type == ETH_BROADCAST_ADDR) {
598 *address = eth_globals.broadcast_addr;
599 } else {
600 fibril_rwlock_read_lock(&eth_globals.devices_lock);
601 device = eth_devices_find(&eth_globals.devices, device_id);
602 if (!device) {
603 fibril_rwlock_read_unlock(&eth_globals.devices_lock);
604 return ENOENT;
605 }
606 *address = device->addr;
607 fibril_rwlock_read_unlock(&eth_globals.devices_lock);
608 }
609
610 return (*address) ? EOK : ENOENT;
611}
612
613/** Registers receiving module service.
614 *
615 * Passes received packets for this service.
616 *
617 * @param[in] service The module service.
618 * @param[in] phone The service phone.
619 * @return EOK on success.
620 * @return ENOENT if the service is not known.
621 * @return ENOMEM if there is not enough memory left.
622 */
623static int eth_register_message(services_t service, int phone)
624{
625 eth_proto_t *proto;
626 int protocol;
627 int index;
628
629 protocol = protocol_map(SERVICE_ETHERNET, service);
630 if (!protocol)
631 return ENOENT;
632
633 fibril_rwlock_write_lock(&eth_globals.protos_lock);
634 proto = eth_protos_find(&eth_globals.protos, protocol);
635 if (proto) {
636 proto->phone = phone;
637 fibril_rwlock_write_unlock(&eth_globals.protos_lock);
638 return EOK;
639 } else {
640 proto = (eth_proto_t *) malloc(sizeof(eth_proto_t));
641 if (!proto) {
642 fibril_rwlock_write_unlock(&eth_globals.protos_lock);
643 return ENOMEM;
644 }
645
646 proto->service = service;
647 proto->protocol = protocol;
648 proto->phone = phone;
649
650 index = eth_protos_add(&eth_globals.protos, protocol, proto);
651 if (index < 0) {
652 fibril_rwlock_write_unlock(&eth_globals.protos_lock);
653 free(proto);
654 return index;
655 }
656 }
657
658 printf("%s: Protocol registered (protocol: %d, service: %d, phone: "
659 "%d)\n", NAME, proto->protocol, proto->service, proto->phone);
660
661 fibril_rwlock_write_unlock(&eth_globals.protos_lock);
662 return EOK;
663}
664
665/** Prepares the packet for sending.
666 *
667 * @param[in] flags The device flags.
668 * @param[in] packet The packet.
669 * @param[in] src_addr The source hardware address.
670 * @param[in] ethertype The ethernet protocol type.
671 * @param[in] mtu The device maximum transmission unit.
672 * @return EOK on success.
673 * @return EINVAL if the packet addresses length is not long
674 * enough.
675 * @return EINVAL if the packet is bigger than the device MTU.
676 * @return ENOMEM if there is not enough memory in the packet.
677 */
678static int
679eth_prepare_packet(int flags, packet_t *packet, uint8_t *src_addr, int ethertype,
680 size_t mtu)
681{
682 eth_header_snap_t *header;
683 eth_header_lsap_t *header_lsap;
684 eth_header_t *header_dix;
685 eth_fcs_t *fcs;
686 uint8_t *src;
687 uint8_t *dest;
688 size_t length;
689 int i;
690 void *padding;
691 eth_preamble_t *preamble;
692
693 i = packet_get_addr(packet, &src, &dest);
694 if (i < 0)
695 return i;
696 if (i != ETH_ADDR)
697 return EINVAL;
698
699 length = packet_get_data_length(packet);
700 if (length > mtu)
701 return EINVAL;
702
703 if (length < ETH_MIN_TAGGED_CONTENT(flags)) {
704 padding = packet_suffix(packet,
705 ETH_MIN_TAGGED_CONTENT(flags) - length);
706 if (!padding)
707 return ENOMEM;
708
709 bzero(padding, ETH_MIN_TAGGED_CONTENT(flags) - length);
710 }
711
712 if (IS_DIX(flags)) {
713 header_dix = PACKET_PREFIX(packet, eth_header_t);
714 if (!header_dix)
715 return ENOMEM;
716
717 header_dix->ethertype = (uint16_t) ethertype;
718 memcpy(header_dix->source_address, src_addr, ETH_ADDR);
719 memcpy(header_dix->destination_address, dest, ETH_ADDR);
720 src = &header_dix->destination_address[0];
721 } else if(IS_8023_2_LSAP(flags)) {
722 header_lsap = PACKET_PREFIX(packet, eth_header_lsap_t);
723 if (!header_lsap)
724 return ENOMEM;
725
726 header_lsap->header.ethertype = htons(length +
727 sizeof(eth_header_lsap_t));
728 header_lsap->lsap.dsap = lsap_unmap(ntohs(ethertype));
729 header_lsap->lsap.ssap = header_lsap->lsap.dsap;
730 header_lsap->lsap.ctrl = IEEE_8023_2_UI;
731 memcpy(header_lsap->header.source_address, src_addr, ETH_ADDR);
732 memcpy(header_lsap->header.destination_address, dest, ETH_ADDR);
733 src = &header_lsap->header.destination_address[0];
734 } else if(IS_8023_2_SNAP(flags)) {
735 header = PACKET_PREFIX(packet, eth_header_snap_t);
736 if (!header)
737 return ENOMEM;
738
739 header->header.ethertype = htons(length +
740 sizeof(eth_header_lsap_t) + sizeof(eth_header_snap_t));
741 header->lsap.dsap = (uint16_t) ETH_LSAP_SNAP;
742 header->lsap.ssap = header->lsap.dsap;
743 header->lsap.ctrl = IEEE_8023_2_UI;
744
745 for (i = 0; i < 3; ++ i)
746 header->snap.protocol[i] = 0;
747
748 header->snap.ethertype = (uint16_t) ethertype;
749 memcpy(header->header.source_address, src_addr, ETH_ADDR);
750 memcpy(header->header.destination_address, dest, ETH_ADDR);
751 src = &header->header.destination_address[0];
752 }
753
754 if (IS_DUMMY(flags)) {
755 preamble = PACKET_PREFIX(packet, eth_preamble_t);
756 if (!preamble)
757 return ENOMEM;
758
759 for (i = 0; i < 7; ++ i)
760 preamble->preamble[i] = ETH_PREAMBLE;
761
762 preamble->sfd = ETH_SFD;
763
764 fcs = PACKET_SUFFIX(packet, eth_fcs_t);
765 if (!fcs)
766 return ENOMEM;
767
768 *fcs = htonl(~compute_crc32(~0U, src, length * 8));
769 }
770
771 return EOK;
772}
773
774/** Sends the packet queue.
775 *
776 * Sends only packet successfully processed by the eth_prepare_packet()
777 * function.
778 *
779 * @param[in] device_id The device identifier.
780 * @param[in] packet The packet queue.
781 * @param[in] sender The sending module service.
782 * @return EOK on success.
783 * @return ENOENT if there no such device.
784 * @return EINVAL if the service parameter is not known.
785 */
786static int eth_send_message(device_id_t device_id, packet_t *packet,
787 services_t sender)
788{
789 eth_device_t *device;
790 packet_t *next;
791 packet_t *tmp;
792 int ethertype;
793 int rc;
794
795 ethertype = htons(protocol_map(SERVICE_ETHERNET, sender));
796 if (!ethertype) {
797 pq_release_remote(eth_globals.net_phone, packet_get_id(packet));
798 return EINVAL;
799 }
800
801 fibril_rwlock_read_lock(&eth_globals.devices_lock);
802 device = eth_devices_find(&eth_globals.devices, device_id);
803 if (!device) {
804 fibril_rwlock_read_unlock(&eth_globals.devices_lock);
805 return ENOENT;
806 }
807
808 /* Process packet queue */
809 next = packet;
810 do {
811 rc = eth_prepare_packet(device->flags, next,
812 (uint8_t *) device->addr->value, ethertype, device->mtu);
813 if (rc != EOK) {
814 /* Release invalid packet */
815 tmp = pq_detach(next);
816 if (next == packet)
817 packet = tmp;
818 pq_release_remote(eth_globals.net_phone,
819 packet_get_id(next));
820 next = tmp;
821 } else {
822 next = pq_next(next);
823 }
824 } while(next);
825
826 /* Send packet queue */
827 if (packet) {
828 netif_send_msg(device->phone, device_id, packet,
829 SERVICE_ETHERNET);
830 }
831
832 fibril_rwlock_read_unlock(&eth_globals.devices_lock);
833 return EOK;
834}
835
836int nil_module_message(ipc_callid_t callid, ipc_call_t *call,
837 ipc_call_t *answer, size_t *answer_count)
838{
839 measured_string_t *address;
840 packet_t *packet;
841 size_t addrlen;
842 size_t prefix;
843 size_t suffix;
844 size_t content;
845 int rc;
846
847 *answer_count = 0;
848 switch (IPC_GET_IMETHOD(*call)) {
849 case IPC_M_PHONE_HUNGUP:
850 return EOK;
851
852 case NET_NIL_DEVICE:
853 return eth_device_message(IPC_GET_DEVICE(*call),
854 IPC_GET_SERVICE(*call), IPC_GET_MTU(*call));
855 case NET_NIL_SEND:
856 rc = packet_translate_remote(eth_globals.net_phone, &packet,
857 IPC_GET_PACKET(*call));
858 if (rc != EOK)
859 return rc;
860 return eth_send_message(IPC_GET_DEVICE(*call), packet,
861 IPC_GET_SERVICE(*call));
862 case NET_NIL_PACKET_SPACE:
863 rc = eth_packet_space_message(IPC_GET_DEVICE(*call), &addrlen,
864 &prefix, &content, &suffix);
865 if (rc != EOK)
866 return rc;
867 IPC_SET_ADDR(*answer, addrlen);
868 IPC_SET_PREFIX(*answer, prefix);
869 IPC_SET_CONTENT(*answer, content);
870 IPC_SET_SUFFIX(*answer, suffix);
871 *answer_count = 4;
872 return EOK;
873 case NET_NIL_ADDR:
874 rc = eth_addr_message(IPC_GET_DEVICE(*call), ETH_LOCAL_ADDR,
875 &address);
876 if (rc != EOK)
877 return rc;
878 return measured_strings_reply(address, 1);
879 case NET_NIL_BROADCAST_ADDR:
880 rc = eth_addr_message(IPC_GET_DEVICE(*call), ETH_BROADCAST_ADDR,
881 &address);
882 if (rc != EOK)
883 return EOK;
884 return measured_strings_reply(address, 1);
885 case IPC_M_CONNECT_TO_ME:
886 return eth_register_message(NIL_GET_PROTO(*call),
887 IPC_GET_PHONE(*call));
888 }
889
890 return ENOTSUP;
891}
892
893int main(int argc, char *argv[])
894{
895 /* Start the module */
896 return nil_module_start(SERVICE_ETHERNET);
897}
898
899/** @}
900 */
Note: See TracBrowser for help on using the repository browser.