mirror of
https://github.com/genodelabs/genode.git
synced 2024-12-23 23:42:32 +00:00
980f3e9c5c
Instead of handing over the maximum available size to the packet data accessors, hand over a size guard that keeps track of the packets boundaries. This commit also moves the size-guard utilitiy header of Ping and NIC Router to the include/net directory making it a part of the net library. It applies the new approach to all net-lib users in the basic repositories. Ping looses its configurability regarding the ICMP data size as this would require an additional method in the size guard which would be used only by Ping. The size guard was also re-worked to fit the fact that a packet can bring a tail as well as a header (Ethernet). Issue #2788
171 lines
4.0 KiB
C++
171 lines
4.0 KiB
C++
/*
|
|
* \brief Ethernet protocol
|
|
* \author Stefan Kalkowski
|
|
* \date 2010-08-19
|
|
*/
|
|
|
|
/*
|
|
* Copyright (C) 2010-2017 Genode Labs GmbH
|
|
*
|
|
* This file is part of the Genode OS framework, which is distributed
|
|
* under the terms of the GNU Affero General Public License version 3.
|
|
*/
|
|
|
|
#ifndef _NET__ETHERNET_H_
|
|
#define _NET__ETHERNET_H_
|
|
|
|
/* Genode includes */
|
|
#include <base/exception.h>
|
|
#include <util/string.h>
|
|
#include <util/construct_at.h>
|
|
#include <util/endian.h>
|
|
#include <net/mac_address.h>
|
|
#include <net/size_guard.h>
|
|
|
|
namespace Net
|
|
{
|
|
class Ethernet_frame;
|
|
|
|
template <Genode::size_t DATA_SIZE>
|
|
class Ethernet_frame_sized;
|
|
}
|
|
|
|
|
|
/**
|
|
* Data layout of this class conforms to the Ethernet II frame
|
|
* (IEEE 802.3).
|
|
*
|
|
* Ethernet-frame-header-format:
|
|
*
|
|
* ----------------------------------------------------------
|
|
* | destination mac address | source mac address | ethertype |
|
|
* | 6 bytes | 6 bytes | 2 bytes |
|
|
* ----------------------------------------------------------
|
|
*/
|
|
class Net::Ethernet_frame
|
|
{
|
|
public:
|
|
|
|
enum Size {
|
|
ADDR_LEN = 6, /* MAC address length in bytes */
|
|
};
|
|
|
|
static Mac_address broadcast() { return Mac_address((Genode::uint8_t)0xff); }
|
|
|
|
private:
|
|
|
|
Genode::uint8_t _dst[ADDR_LEN]; /* destination mac address */
|
|
Genode::uint8_t _src[ADDR_LEN]; /* source mac address */
|
|
Genode::uint16_t _type; /* encapsulated protocol */
|
|
unsigned _data[0]; /* encapsulated data */
|
|
|
|
public:
|
|
|
|
enum { MIN_SIZE = 64 };
|
|
|
|
/**
|
|
* Id representing encapsulated protocol.
|
|
*/
|
|
enum class Type : Genode::uint16_t {
|
|
IPV4 = 0x0800,
|
|
ARP = 0x0806,
|
|
};
|
|
|
|
template <typename T>
|
|
T const &data(Size_guard &size_guard) const
|
|
{
|
|
size_guard.consume_head(sizeof(T));
|
|
T const &obj = *(T *)(_data);
|
|
|
|
/* Ethernet may have a tail whose size must be considered */
|
|
Genode::size_t const unconsumed = size_guard.unconsumed();
|
|
size_guard.consume_tail(unconsumed + sizeof(T) -
|
|
obj.size(unconsumed));
|
|
return obj;
|
|
}
|
|
|
|
template <typename T>
|
|
T &data(Size_guard &size_guard)
|
|
{
|
|
size_guard.consume_head(sizeof(T));
|
|
T &obj = *(T *)(_data);
|
|
|
|
/* Ethernet may have a tail whose size must be considered */
|
|
Genode::size_t const max_obj_sz = size_guard.unconsumed() + sizeof(T);
|
|
size_guard.consume_tail(max_obj_sz - obj.size(max_obj_sz));
|
|
return obj;
|
|
}
|
|
|
|
template <typename T>
|
|
T &construct_at_data(Size_guard &size_guard)
|
|
{
|
|
size_guard.consume_head(sizeof(T));
|
|
return *Genode::construct_at<T>(_data);
|
|
}
|
|
|
|
static Ethernet_frame &construct_at(void *base,
|
|
Size_guard &size_guard)
|
|
{
|
|
size_guard.consume_head(sizeof(Ethernet_frame));
|
|
return *Genode::construct_at<Ethernet_frame>(base);
|
|
}
|
|
|
|
static Ethernet_frame &cast_from(void *base,
|
|
Size_guard &size_guard)
|
|
{
|
|
size_guard.consume_head(sizeof(Ethernet_frame));
|
|
return *(Ethernet_frame *)base;
|
|
}
|
|
|
|
|
|
/***************
|
|
** Accessors **
|
|
***************/
|
|
|
|
Mac_address dst() const { return Mac_address((void *)_dst); }
|
|
Mac_address src() const { return Mac_address((void *)_src); }
|
|
Type type() const { return (Type)host_to_big_endian(_type); }
|
|
|
|
void dst(Mac_address v) { v.copy(&_dst); }
|
|
void src(Mac_address v) { v.copy(&_src); }
|
|
void type(Type type) { _type = host_to_big_endian((Genode::uint16_t)type); }
|
|
|
|
|
|
/*********
|
|
** log **
|
|
*********/
|
|
|
|
void print(Genode::Output &output) const;
|
|
|
|
} __attribute__((packed));
|
|
|
|
|
|
template <Genode::size_t DATA_SIZE>
|
|
class Net::Ethernet_frame_sized : public Ethernet_frame
|
|
{
|
|
private:
|
|
|
|
enum {
|
|
HS = sizeof(Ethernet_frame),
|
|
DS = DATA_SIZE + HS >= MIN_SIZE ? DATA_SIZE : MIN_SIZE - HS,
|
|
};
|
|
|
|
Genode::uint8_t _data[DS];
|
|
Genode::uint32_t _checksum;
|
|
|
|
public:
|
|
|
|
Ethernet_frame_sized(Mac_address dst_in, Mac_address src_in,
|
|
Type type_in)
|
|
:
|
|
Ethernet_frame(sizeof(Ethernet_frame))
|
|
{
|
|
dst(dst_in);
|
|
src(src_in);
|
|
type(type_in);
|
|
}
|
|
|
|
} __attribute__((packed));
|
|
|
|
#endif /* _NET__ETHERNET_H_ */
|