Samuka007/asterinas
1
0
Fork 0
mirror of https://github.com/asterinas/asterinas.git synced 2025-06-13 23:36:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

Use static IP addresses

Browse Source
This commit is contained in:
Ruihan Li 2024-09-19 11:40:28 +08:00 committed by Tate, Hongliang Tian
parent 9abdebbae3
commit d62bb1ca76
3 changed files with 34 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

72
kernel/libs/aster-bigtcp/src/iface/phy/ether.rs
View File

@ -2,11 +2,9 @@
use alloc::sync::Arc;
use ostd::prelude::*;
use smoltcp::{
iface::{Config, SocketHandle, SocketSet},
socket::dhcpv4,
wire::{self, EthernetAddress, IpCidr},
iface::Config,
wire::{self, EthernetAddress, Ipv4Address, Ipv4Cidr},
};
use crate::{
@ -19,67 +17,35 @@ use crate::{
pub struct EtherIface<D: WithDevice, E> {
driver: D,
common: IfaceCommon<E>,
dhcp_handle: SocketHandle,
}
impl<D: WithDevice, E> EtherIface<D, E> {
pub fn new(driver: D, ether_addr: EthernetAddress, ext: E) -> Arc<Self> {
pub fn new(
driver: D,
ether_addr: EthernetAddress,
ip_cidr: Ipv4Cidr,
gateway: Ipv4Address,
ext: E,
) -> Arc<Self> {
let interface = driver.with(|device| {
let ip_addr = IpCidr::new(wire::IpAddress::Ipv4(wire::Ipv4Address::UNSPECIFIED), 0);
let config = Config::new(wire::HardwareAddress::Ethernet(ether_addr));
let now = get_network_timestamp();
let mut interface = smoltcp::iface::Interface::new(config, device, now);
interface.update_ip_addrs(|ip_addrs| {
debug_assert!(ip_addrs.is_empty());
ip_addrs.push(ip_addr).unwrap();
ip_addrs.push(wire::IpCidr::Ipv4(ip_cidr)).unwrap();
});
interface
.routes_mut()
.add_default_ipv4_route(gateway)
.unwrap();
interface
});
let common = IfaceCommon::new(interface, ext);
let mut socket_set = common.sockets();
let dhcp_handle = init_dhcp_client(&mut socket_set);
drop(socket_set);
Arc::new(Self {
driver,
common,
dhcp_handle,
})
}
/// FIXME: Once we have user program dhcp client, we may remove dhcp logic from kernel.
pub fn process_dhcp(&self) {
let mut socket_set = self.common.sockets();
let dhcp_socket: &mut dhcpv4::Socket = socket_set.get_mut(self.dhcp_handle);
let Some(dhcpv4::Event::Configured(config)) = dhcp_socket.poll() else {
return;
};
let ip_addr = IpCidr::Ipv4(config.address);
let mut interface = self.common.interface();
println!("[DHCP] Local IP address: {:?}", ip_addr,);
interface.update_ip_addrs(|ipaddrs| {
if let Some(addr) = ipaddrs.iter_mut().next() {
// already has ipaddrs
*addr = ip_addr
} else {
// does not has ip addr
ipaddrs.push(ip_addr).unwrap();
}
});
if let Some(router) = config.router {
println!("[DHCP] Router IP address: {:?}", router);
interface
.routes_mut()
.add_default_ipv4_route(router)
.unwrap();
}
Arc::new(Self { driver, common })
}
}
@ -94,14 +60,6 @@ impl<D: WithDevice, E: Send + Sync> Iface<E> for EtherIface<D, E> {
self.driver.with(|device| {
let next_poll = self.common.poll(&mut *device);
schedule_next_poll(next_poll);
self.process_dhcp();
});
}
}
/// Register a dhcp socket.
fn init_dhcp_client(socket_set: &mut SocketSet) -> SocketHandle {
let dhcp_socket = dhcpv4::Socket::new();
socket_set.add(dhcp_socket)
}

9
kernel/libs/aster-bigtcp/src/iface/phy/ip.rs
View File

@ -2,7 +2,10 @@
use alloc::sync::Arc;
use smoltcp::{iface::Config, wire::IpCidr};
use smoltcp::{
iface::Config,
wire::{self, Ipv4Cidr},
};
use crate::{
device::WithDevice,
@ -17,7 +20,7 @@ pub struct IpIface<D: WithDevice, E> {
}
impl<D: WithDevice, E> IpIface<D, E> {
pub fn new(driver: D, ip_cidr: IpCidr, ext: E) -> Arc<Self> {
pub fn new(driver: D, ip_cidr: Ipv4Cidr, ext: E) -> Arc<Self> {
let interface = driver.with(|device| {
let config = Config::new(smoltcp::wire::HardwareAddress::Ip);
let now = get_network_timestamp();
@ -25,7 +28,7 @@ impl<D: WithDevice, E> IpIface<D, E> {
let mut interface = smoltcp::iface::Interface::new(config, device, now);
interface.update_ip_addrs(|ip_addrs| {
debug_assert!(ip_addrs.is_empty());
ip_addrs.push(ip_cidr).unwrap();
ip_addrs.push(wire::IpCidr::Ipv4(ip_cidr)).unwrap();
});
interface
});

20
kernel/src/net/iface/init.rs
View File

@ -33,10 +33,17 @@ pub fn init() {
}
fn new_virtio() -> Arc<Iface> {
use aster_bigtcp::{iface::EtherIface, wire::EthernetAddress};
use aster_bigtcp::{
iface::EtherIface,
wire::{EthernetAddress, Ipv4Address, Ipv4Cidr},
};
use aster_network::AnyNetworkDevice;
use aster_virtio::device::network::DEVICE_NAME;
const VIRTIO_ADDRESS: Ipv4Address = Ipv4Address::new(10, 0, 2, 15);
const VIRTIO_ADDRESS_PREFIX_LEN: u8 = 24; // mask: 255.255.255.0
const VIRTIO_GATEWAY: Ipv4Address = Ipv4Address::new(10, 0, 2, 2);
let virtio_net = aster_network::get_device(DEVICE_NAME).unwrap();
let ether_addr = virtio_net.lock().mac_addr().0;
@ -58,6 +65,8 @@ fn new_virtio() -> Arc<Iface> {
EtherIface::new(
Wrapper(virtio_net),
EthernetAddress(ether_addr),
Ipv4Cidr::new(VIRTIO_ADDRESS, VIRTIO_ADDRESS_PREFIX_LEN),
VIRTIO_GATEWAY,
IfaceExt::new("virtio".to_owned()),
)
}
@ -66,13 +75,10 @@ fn new_loopback() -> Arc<Iface> {
use aster_bigtcp::{
device::{Loopback, Medium},
iface::IpIface,
wire::{IpAddress, IpCidr, Ipv4Address},
wire::{Ipv4Address, Ipv4Cidr},
};
const LOOPBACK_ADDRESS: IpAddress = {
let ipv4_addr = Ipv4Address::new(127, 0, 0, 1);
IpAddress::Ipv4(ipv4_addr)
};
const LOOPBACK_ADDRESS: Ipv4Address = Ipv4Address::new(127, 0, 0, 1);
const LOOPBACK_ADDRESS_PREFIX_LEN: u8 = 8; // mask: 255.0.0.0
struct Wrapper(Mutex<Loopback>);
@ -91,7 +97,7 @@ fn new_loopback() -> Arc<Iface> {
IpIface::new(
Wrapper(Mutex::new(Loopback::new(Medium::Ip))),
IpCidr::new(LOOPBACK_ADDRESS, LOOPBACK_ADDRESS_PREFIX_LEN),
Ipv4Cidr::new(LOOPBACK_ADDRESS, LOOPBACK_ADDRESS_PREFIX_LEN),
IfaceExt::new("lo".to_owned()),
) as _
}