Low-earth-orbit (LEO) mega-constellations with inter-satellite links (ISLs) are becoming the Internet backbone in space. Satellites within LEO often need the capability to enforce data forwarding paths. For example, they may need to bypass the satellites over the untrusted areas for the data of mission-critical applications or minimize latency for the data of time-sensitive applications. However, typical source/segment routing techniques (e.g., SRv6) suffer from scalability issue, since they record source-route-style forwarding information via the list-based structure. This results in great payload and forwarding overhead. To overcome this drawback, we propose a source/segment routing architecture for LEO mega-constellations, which is named as Link-identified Routing (LiR). LiR leverages in-packet bloom filter (BF) to record source-route-style forwarding information. BF could efficiently record multiple elements via a probabilistic data structure, but overlooks the order of the encoded elements. To address this, LiR identifies each unidirectional ISL, and represents the path by encoding ISL identifiers into BF. We investigate how to optimize BF configuration and ISL encoding policy to address false positives caused by BF. We implement LiR in Linux kernel and develop a container-based emulator for performance evaluation. Results show that LiR significantly outperforms SRv6 in terms of packet forwarding and data delivery efficiency.

Low- earth-orbit (LEO) satellite constellations (e.g., Starlink) are becoming a necessary component of future Internet. There have been increasing studies on LEO satellite networking. It is a crucial problem how to evaluate these studies in a systematic and reproducible manner. In this paper, we present OpenSN, i.e., an open source library for emulating large-scale satellite network (SN). Different from Mininet-based SN emulators (e.g., LeoEM), OpenSN adopts container-based virtualization, thus allows for running distributed routing software on each node, and can achieve horizontal scalability via flexible multi-machine extension. Compared to other container-based SN emulators (e.g., StarryNet), OpenSN streamlines the interaction with Docker command line interface and significantly reduces unnecessary operations of creating virtual links. These modifications improve emulation efficiency and vertical scalability on a single machine. Furthermore, OpenSN separates user-defined configuration from container network management via a Key-Value Database that records the necessary information for SN emulation. Such a separation architecture enhances the function extensibility. To sum up, OpenSN exhibits advantages in efficiency, scalability, and extensibility, thus is a valuable open source library that empowers research on LEO satellite networking. Experiment results show that OpenSN constructs mega-constellations 5X-10X faster than StarryNet, and updates link state 2X-4X faster than LeoEM. We also verify the scalability of OpenSN by successfully emulating the five-shell Starlink constellation with a total of 4408 satellites.

Low earth orbit (LEO) satellite networks have the potential to provide low-latency communication with global coverage. To unleash this potential, it is crucial to achieve efficient data delivery. In this paper, we analyze the topology characteristics of LEO satellite networks, and propose a source-route-style forwarding framework. Specifically, we leverage the deterministic neighbor relationship and identify all the unidi-rectional inter-satellite links (ISLs). Moreover, our framework utilizes the in-packet bloom filter (BF) to store the source-route-style forwarding information. This way, the source satellite could encode multiple ISL identifiers into the BF, which actually specifies the forwarding path. The intermediate satellites only need to check whether the outgoing ISLs are encoded and forward packets accordingly. Due to false positives caused by BF, the more ISLs are encoded at a time, the more redundant forwardings emerge. To reduce forwarding overhead, we take into account segment encoding, allowing the source and intermediate satellites to encode part of ISLs towards the destination. Overall, segment encoding seeks the right balance between forwarding overhead and encoding delay. We characterize a wide range of segment encoding policy in a unified framework, and derive the expected forwarding overhead in a closed-form. The segment encoding design is formulated as a binary non-linear programming, which is NP-hard. To overcome the challenge, we leverage its decomposable structure, and propose an efficient algorithm to solve it optimally. Finally, we validate our analytical results via packet-level experiments. Results also show that our proposed segment encoding policy significantly reduces the queuing delay compared to source encoding.