cs144 finised Thank you my friend

Author: elecDancing

libsponge/byte_stream.cc

@@ -45,15 +45,8 @@ string ByteStream::peek_output(const size_t len) const {
     size_t length = len;
     if (length > _buffer.size())
         length = _buffer.size();
-    string tempstr;
-    // return string().assign(_buffer.begin(), _buffer.begin() + length);
-    for (auto it = _buffer.begin(); it < _buffer.begin() + length; ++it) {
-        if(!_buffer.empty()){
-        tempstr += *it;
-        }
-    }
-    return tempstr;
-    
+    return string().assign(_buffer.begin(), _buffer.begin() + length);
+   
 }
 
 //! \param[in] len bytes will be removed from the output side of the buffer

libsponge/byte_stream.hh

@@ -4,7 +4,7 @@
  * @Author: xp.Zhang
  * @Date: 2023-07-12 15:22:53
  * @LastEditors: xp.Zhang
- * @LastEditTime: 2023-09-15 10:59:01
+ * @LastEditTime: 2023-11-09 00:01:16
  */
 #ifndef SPONGE_LIBSPONGE_BYTE_STREAM_HH
 #define SPONGE_LIBSPONGE_BYTE_STREAM_HH
@@ -24,6 +24,7 @@
 class ByteStream {
   private:
     // Your code here -- add private members as necessary.
+
     std::deque<char> _buffer = {};
     size_t _capacity = 0;
     size_t _readCount = 0;

libsponge/network_interface.cc

@@ -4,7 +4,7 @@
  * @Author: xp.Zhang
  * @Date: 2023-11-06 18:00:19
  * @LastEditors: xp.Zhang
- * @LastEditTime: 2023-11-07 04:36:55
+ * @LastEditTime: 2023-11-07 22:41:46
  */
 #include "network_interface.hh"
 
@@ -62,9 +62,9 @@ void NetworkInterface::send_datagram(const InternetDatagram &dgram, const Addres
 //! \param[in] frame the incoming Ethernet frame
 optional<InternetDatagram> NetworkInterface::recv_frame(const EthernetFrame &frame) {
     //determine whether frame needs to be receives locally
-    bool isArpFrame = _ethernet_address_equal(frame.header().dst, ETHERNET_BROADCAST);
+    bool isBoardcastArpFrame = _ethernet_address_equal(frame.header().dst, ETHERNET_BROADCAST);
     bool isnormalFrame = _ethernet_address_equal(frame.header().dst, _ethernet_address);
-    if(!isArpFrame && !isnormalFrame)
+    if(!isBoardcastArpFrame && !isnormalFrame)
         return nullopt;
     else if (frame.header().type == EthernetHeader::TYPE_IPv4) // return InternetDatagram
     {

libsponge/router.cc

@@ -1,3 +1,11 @@
+/*
+ * @Descripttion: 
+ * @version: 
+ * @Author: xp.Zhang
+ * @Date: 2023-11-07 23:01:50
+ * @LastEditors: xp.Zhang
+ * @LastEditTime: 2023-11-08 05:57:26
+ */
 #include "router.hh"
 
 #include <iostream>
@@ -28,15 +36,52 @@ void Router::add_route(const uint32_t route_prefix,
                        const size_t interface_num) {
     cerr << "DEBUG: adding route " << Address::from_ipv4_numeric(route_prefix).ip() << "/" << int(prefix_length)
          << " => " << (next_hop.has_value() ? next_hop->ip() : "(direct)") << " on interface " << interface_num << "\n";
-
-    DUMMY_CODE(route_prefix, prefix_length, next_hop, interface_num);
-    // Your code here.
+    RouteItem temp;
+    temp.route_prefix = route_prefix;
+    temp.prefix_length = prefix_length;
+    temp.next_hop = next_hop;
+    temp.interface_num = interface_num;
+    _route_list.push_back(temp);
 }
 
 //! \param[in] dgram The datagram to be routed
-void Router::route_one_datagram(InternetDatagram &dgram) {
-    DUMMY_CODE(dgram);
-    // Your code here.
+void Router::route_one_datagram(InternetDatagram &dgram) { 
+    bool route_found = false;
+    RouteItem item;
+    uint32_t dst_ip = dgram.header().dst;
+    // Traverse the routing table
+    for (size_t i = 0; i < _route_list.size(); ++i){
+        if(prefix_equal(dst_ip, _route_list[i].route_prefix, _route_list[i].prefix_length)){
+            if(!route_found ||item.prefix_length < _route_list[i].prefix_length){
+                item = _route_list[i];
+                route_found = true;
+            }
+        }
+    }
+    if(!route_found){
+        return;
+    }
+    if (dgram.header().ttl <= 1) {
+        return;
+    }
+    dgram.header().ttl--;
+    //transfor to next hop
+    if(item.next_hop.has_value()){
+        _interfaces[item.interface_num].send_datagram(dgram, item.next_hop.value());
+    }
+    //through interface 
+    else{
+        _interfaces[item.interface_num].send_datagram(dgram, Address::from_ipv4_numeric(dgram.header().dst));
+    }
+}
+
+bool Router::prefix_equal(uint32_t ip1, uint32_t ip2, uint8_t len){
+    //determin the number of digits need to compare
+    uint32_t offset = 0xffffffff << (32 - len);
+    uint32_t a = ip1 & offset;
+    uint32_t b = ip2 & offset;
+    cout << "IPcmp  " << std::hex <<a << "  " << std::hex << b << " " << std::hex <<offset << endl;
+    return a == b;
 }
 
 void Router::route() {

libsponge/router.hh

@@ -1,3 +1,11 @@
+/*
+ * @Descripttion: 
+ * @version: 
+ * @Author: xp.Zhang
+ * @Date: 2023-11-07 23:01:50
+ * @LastEditors: xp.Zhang
+ * @LastEditTime: 2023-11-08 01:12:10
+ */
 #ifndef SPONGE_LIBSPONGE_ROUTER_HH
 #define SPONGE_LIBSPONGE_ROUTER_HH
 
@@ -41,8 +49,21 @@ class AsyncNetworkInterface : public NetworkInterface {
 //! \brief A router that has multiple network interfaces and
 //! performs longest-prefix-match routing between them.
 class Router {
+    private:
+
+    struct RouteItem{
+        uint32_t route_prefix = 0;
+        uint8_t prefix_length = 0;
+        std::optional<Address> next_hop = std::nullopt;
+        size_t interface_num = 0;
+    };
+
+    std::vector<RouteItem> _route_list{};
+    bool prefix_equal(uint32_t ip1, uint32_t ip2, uint8_t len);
+    
     //! The router's collection of network interfaces
-    std::vector<AsyncNetworkInterface> _interfaces{};
+    std::vector<AsyncNetworkInterface>
+        _interfaces{};
 
     //! Send a single datagram from the appropriate outbound interface to the next hop,
     //! as specified by the route with the longest prefix_length that matches the

tests/a.out

@@ -4,13 +4,16 @@
  * @Author: xp.Zhang
  * @Date: 2023-07-24 10:13:04
  * @LastEditors: xp.Zhang
- * @LastEditTime: 2023-07-24 14:14:22
+ * @LastEditTime: 2023-11-08 01:05:45
  */
 #include <cstdint>
+#include <iostream>
 #include <ostream>
-#include "wrapping_integers.hh"
+// #include "wrapping_integers.hh"
 int main()
 {
-    unwrap(WrappingInt32(UINT32_MAX - 1), WrappingInt32(0), 3 * (1ul << 32));
+    //unwrap(WrappingInt32(UINT32_MAX - 1), WrappingInt32(0), 3 * (1ul << 32));
+    uint32_t a = 0xffffffff << 32;
+    std::cout << a << std::endl;
     return 0;
 }