Use static IP addresses

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

@@ -2,11 +2,9 @@
 
 use alloc::sync::Arc;
 
-use ostd::prelude::*;
 use smoltcp::{
-    iface::{Config, SocketHandle, SocketSet},
+    iface::Config,
-    socket::dhcpv4,
+    wire::{self, EthernetAddress, Ipv4Address, Ipv4Cidr},
-    wire::{self, EthernetAddress, IpCidr},
 };
 
 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();
+        Arc::new(Self { driver, common })
-        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();
-        }
     }
 }
 
@@ -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)
-}

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

@@ -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
         });

kernel/src/net/iface/init.rs

@@ -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 = {
+    const LOOPBACK_ADDRESS: Ipv4Address = Ipv4Address::new(127, 0, 0, 1);
-        let ipv4_addr = Ipv4Address::new(127, 0, 0, 1);
-        IpAddress::Ipv4(ipv4_addr)
-    };
     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 _
 }