os/net/
config.rs

1use crate::{earlyprintln, net::interface::NETWORK_INTERFACE_MANAGER};
2use alloc::string::String;
3use smoltcp::wire::{IpAddress, IpCidr, Ipv4Address};
4
5/// 网络配置错误
6#[derive(Debug)]
7pub enum NetworkConfigError {
8    InterfaceNotFound,
9    InvalidAddress,
10    InvalidSubnet,
11    InvalidGateway,
12    ConfigFailed,
13}
14
15/// 网络配置管理器
16pub struct NetworkConfigManager;
17
18impl NetworkConfigManager {
19    /// 解析点分十进制子网掩码并计算前缀长度
20    ///
21    /// # 参数
22    /// * `mask` - 点分十进制格式的子网掩码字符串 (如 "255.255.255.0")
23    ///
24    /// # 返回值
25    /// * `Ok(u8)` - 成功时返回前缀长度 (0-32)
26    /// * `Err(NetworkConfigError)` - 失败时返回错误
27    ///
28    /// # 示例
29    /// ```
30    /// parse_subnet_mask("255.255.255.0") // 返回 Ok(24)
31    /// parse_subnet_mask("255.255.0.0")   // 返回 Ok(16)
32    /// parse_subnet_mask("255.255.255.128") // 返回 Ok(25)
33    /// parse_subnet_mask("255.255.255.3") // 返回 Err (无效掩码)
34    /// ```
35    fn parse_subnet_mask(mask: &str) -> Result<u8, NetworkConfigError> {
36        // 解析点分十进制字符串为4个字节
37        let octets: Result<alloc::vec::Vec<u8>, _> =
38            mask.split('.').map(|s| s.parse::<u8>()).collect();
39
40        let octets = octets.map_err(|_| NetworkConfigError::InvalidSubnet)?;
41
42        // 必须是4个字节
43        if octets.len() != 4 {
44            return Err(NetworkConfigError::InvalidSubnet);
45        }
46
47        // 将4个字节转换为32位整数
48        let mask_u32 = ((octets[0] as u32) << 24)
49            | ((octets[1] as u32) << 16)
50            | ((octets[2] as u32) << 8)
51            | (octets[3] as u32);
52
53        // 验证掩码的有效性：必须是连续的1后跟连续的0
54        // 例如: 11111111111111111111111100000000 (0xFFFFFF00) 是有效的
55        //       11111111111111110000000011111111 (0xFFFF00FF) 是无效的
56
57        // 计算前缀长度（前导1的个数）
58        let prefix_length = mask_u32.leading_ones() as u8;
59
60        // 验证：如果有 n 个前导1，那么掩码应该等于 (0xFFFFFFFF << (32 - n))
61        // 这确保了所有的1都是连续的
62        if prefix_length == 0 {
63            // 特殊情况：掩码为 0.0.0.0
64            if mask_u32 == 0 {
65                return Ok(0);
66            } else {
67                return Err(NetworkConfigError::InvalidSubnet);
68            }
69        } else if prefix_length == 32 {
70            // 特殊情况：掩码为 255.255.255.255
71            if mask_u32 == 0xFFFFFFFF {
72                return Ok(32);
73            } else {
74                return Err(NetworkConfigError::InvalidSubnet);
75            }
76        } else {
77            // 一般情况：验证掩码格式
78            let expected_mask = 0xFFFFFFFFu32 << (32 - prefix_length);
79            if mask_u32 != expected_mask {
80                return Err(NetworkConfigError::InvalidSubnet);
81            }
82            return Ok(prefix_length);
83        }
84    }
85
86    /// 初始化默认网络接口配置
87    pub fn init_default_interface() -> Result<(), NetworkConfigError> {
88        earlyprintln!("Initializing default network configuration...");
89
90        // 先获取接口的Arc，然后释放全局锁
91        // 避免在持有NETWORK_INTERFACE_MANAGER锁时操作接口字段锁
92        let interface = {
93            let binding = NETWORK_INTERFACE_MANAGER.lock();
94            binding.get_interfaces().first().cloned()
95        }; // NETWORK_INTERFACE_MANAGER锁已释放
96
97        if let Some(interface) = interface {
98            earlyprintln!("Configuring interface: {}", interface.name());
99
100            // 设置默认IP地址
101            let ip_cidr = IpCidr::new(IpAddress::v4(192, 168, 1, 100), 24);
102            interface.add_ip_address(ip_cidr);
103            earlyprintln!("Set IP address: 192.168.1.100/24");
104
105            // 设置默认网关
106            let gateway = Ipv4Address::new(192, 168, 1, 1);
107            interface.set_ipv4_gateway(Some(gateway));
108            earlyprintln!("Set default gateway: 192.168.1.1");
109
110            // Initialize global interface for socket operations
111            let smoltcp_iface = interface.create_smoltcp_interface();
112            use crate::net::socket::init_global_interface;
113            init_global_interface(smoltcp_iface.into_interface());
114            earlyprintln!("Initialized global network interface");
115
116            Ok(())
117        } else {
118            earlyprintln!("No network interfaces found to configure");
119            Err(NetworkConfigError::InterfaceNotFound)
120        }
121    }
122
123    /// 设置网络接口IP地址
124    pub fn set_ip_address(
125        interface_name: &str,
126        ip: &str,
127        prefix: u8,
128    ) -> Result<(), NetworkConfigError> {
129        // 先获取接口的Arc，然后释放全局锁
130        let interface = NETWORK_INTERFACE_MANAGER
131            .lock()
132            .find_interface_by_name(interface_name)
133            .cloned(); // clone Arc，然后锁自动释放
134
135        if let Some(interface) = interface {
136            // 解析IP地址
137            match ip.parse::<Ipv4Address>() {
138                Ok(ipv4) => {
139                    let ip_cidr = IpCidr::new(IpAddress::Ipv4(ipv4), prefix);
140                    interface.add_ip_address(ip_cidr);
141                    earlyprintln!("Set IP address for {}: {}/{}", interface_name, ip, prefix);
142                    Ok(())
143                }
144                Err(_) => Err(NetworkConfigError::InvalidAddress),
145            }
146        } else {
147            Err(NetworkConfigError::InterfaceNotFound)
148        }
149    }
150
151    /// 设置默认网关
152    pub fn set_default_gateway(
153        interface_name: &str,
154        gateway: &str,
155    ) -> Result<(), NetworkConfigError> {
156        // 先获取接口的Arc，然后释放全局锁
157        let interface = NETWORK_INTERFACE_MANAGER
158            .lock()
159            .find_interface_by_name(interface_name)
160            .cloned(); // clone Arc，然后锁自动释放
161
162        if let Some(interface) = interface {
163            // 解析网关地址
164            match gateway.parse::<Ipv4Address>() {
165                Ok(gateway_ipv4) => {
166                    interface.set_ipv4_gateway(Some(gateway_ipv4));
167                    earlyprintln!("Set default gateway for {}: {}", interface_name, gateway);
168                    Ok(())
169                }
170                Err(_) => Err(NetworkConfigError::InvalidGateway),
171            }
172        } else {
173            Err(NetworkConfigError::InterfaceNotFound)
174        }
175    }
176
177    /// 获取网络接口配置信息
178    pub fn get_interface_config(interface_name: &str) -> Result<String, NetworkConfigError> {
179        // 先获取接口的Arc，然后释放全局锁
180        let interface = NETWORK_INTERFACE_MANAGER
181            .lock()
182            .find_interface_by_name(interface_name)
183            .cloned(); // clone Arc，然后锁自动释放
184
185        if let Some(interface) = interface {
186            let mut config = alloc::format!("Interface: {}\n", interface.name());
187            config.push_str(&alloc::format!(
188                "MAC Address: {}\n",
189                interface.mac_address()
190            ));
191
192            // 添加IP地址信息
193            let ip_addresses = interface.ip_addresses();
194            if !ip_addresses.is_empty() {
195                config.push_str("IP Addresses:\n");
196                for ip in ip_addresses {
197                    config.push_str(&alloc::format!("  {}\n", ip));
198                }
199            } else {
200                config.push_str("No IP addresses configured\n");
201            }
202
203            // 添加网关信息
204            if let Some(gateway) = interface.ipv4_gateway() {
205                config.push_str(&alloc::format!("Default Gateway: {}\n", gateway));
206            } else {
207                config.push_str("No default gateway configured\n");
208            }
209
210            Ok(config)
211        } else {
212            Err(NetworkConfigError::InterfaceNotFound)
213        }
214    }
215
216    /// 设置网络接口配置
217    pub fn set_interface_config(
218        interface_name: &str,
219        ip: &str,
220        gateway: &str,
221        mask: &str,
222    ) -> Result<(), NetworkConfigError> {
223        // 先获取接口的Arc，然后释放全局锁
224        let interface = NETWORK_INTERFACE_MANAGER
225            .lock()
226            .find_interface_by_name(interface_name)
227            .cloned(); // clone Arc，然后锁自动释放
228
229        if let Some(interface) = interface {
230            // 解析IP地址
231            let ip_address = match ip.parse::<Ipv4Address>() {
232                Ok(ipv4) => ipv4,
233                Err(_) => return Err(NetworkConfigError::InvalidAddress),
234            };
235
236            // 解析网关地址
237            let gateway_address = match gateway.parse::<Ipv4Address>() {
238                Ok(gw) => gw,
239                Err(_) => return Err(NetworkConfigError::InvalidGateway),
240            };
241
242            // 解析子网掩码，并计算前缀长度
243            let prefix_length = Self::parse_subnet_mask(mask)?;
244
245            // 设置IP地址
246            let ip_cidr = IpCidr::new(IpAddress::Ipv4(ip_address), prefix_length);
247            interface.add_ip_address(ip_cidr);
248
249            // 设置网关
250            interface.set_ipv4_gateway(Some(gateway_address));
251
252            earlyprintln!(
253                "Set interface config for {}: IP={}/{}, Gateway={}",
254                interface_name,
255                ip,
256                prefix_length,
257                gateway
258            );
259            Ok(())
260        } else {
261            Err(NetworkConfigError::InterfaceNotFound)
262        }
263    }
264
265    /// 列出所有网络接口
266    pub fn list_interfaces() -> String {
267        let manager = NETWORK_INTERFACE_MANAGER.lock();
268        let interfaces = manager.get_interfaces();
269        let mut result = alloc::string::String::new();
270
271        if interfaces.is_empty() {
272            result.push_str("No network interfaces available\n");
273        } else {
274            result.push_str("Available network interfaces:\n");
275            for (index, interface) in interfaces.iter().enumerate() {
276                result.push_str(&alloc::format!("{}: {}\n", index + 1, interface.name()));
277                result.push_str(&alloc::format!("   MAC: {}\n", interface.mac_address()));
278            }
279        }
280
281        result
282    }
283}
os/net/config.rs

os/net/
config.rs
