[backport] Added BGP message type ROUTE_REFRESH

pajama-coder · pajama-coder · commit 8534aae84cc6 · 2025-02-21T17:39:22.000+08:00
diff --git a/samples/bgp/config-example.yaml b/samples/bgp/config-example.yaml
@@ -1,5 +1,5 @@
 as: 1234
-id: 127.17.0.1
+id: 172.17.0.1
 peers:
   - 172.17.0.2
 ipv4:
diff --git a/samples/bgp/main.js b/samples/bgp/main.js
@@ -8,7 +8,7 @@ var isExiting = false
 var $peer
 
 var session = pipeline($=>$
-  .mux(() => $peer).to($=>$
+  .mux(() => $peer, { maxQueue: 0 }).to($=>$
     .encodeBGP({ enableAS4: () => $peer.isAS4() })
     .handleMessage(msg => console.debug('>>>', $peer.state(), msg.payload))
     .connect(() => $peer.destination, { idleTimeout: 0 })
diff --git a/samples/bgp/peer.js b/samples/bgp/peer.js
@@ -1,7 +1,7 @@
 export default function (config, address) {
 
   var AS_TRANS = 23456
-  var MY_AS = config.as
+  var MY_AS = Number.parseInt(config.as)
   var BGP_IDENTIFIER = config.id
   var HOLD_TIME = (holdTime in config ? config.holdTime : 90)
   var IPV4_NEXT_HOP = os.env.BGP_SPEAKER_IPV4_NEXTHOP || config.ipv4.nextHop
@@ -170,6 +170,11 @@ export default function (config, address) {
                 code: 1,
                 value: new Data([0, 2, 0, 1]),
               },
+              {
+                // Route Refresh Capability
+                code: 2,
+                value: new Data,
+              },
               {
                 // Graceful Restart Capability
                 code: 64,
@@ -243,38 +248,41 @@ export default function (config, address) {
 
     // Routes for IPv6 unicast
     if (hasIPv6) {
+      var pathAttributes = [...commonPathAttrs]
+      if (config.ipv6.reachable.length > 0) {
+        pathAttributes.push({
+          // MP_REACH_NLRI
+          code: 14,
+          value: new Data([
+            // IPv6 unicast
+            0, 2, 1,
+            // Next Hop
+            16, ...ipv6(IPV6_NEXT_HOP).data,
+            // No SNPAs
+            0,
+            // NLRI
+            ...config.ipv6.reachable.flatMap(a => ipv6Prefix(a)),
+          ]),
+          optional: true,
+        })
+      }
+      if (config.ipv6.unreachable.length > 0) {
+        pathAttributes.push({
+          // MP_UNREACH_NLRI
+          code: 15,
+          value: new Data([
+            // IPv6 unicast
+            0, 2, 1,
+            // NLRI
+            ...config.ipv6.unreachable.flatMap(a => ipv6Prefix(a)),
+          ]),
+          optional: true,
+        })
+      }
       messages.push(new Message(null, {
         type: 'UPDATE',
         body: {
-          pathAttributes: [
-            ...commonPathAttrs,
-            {
-              // MP_REACH_NLRI
-              code: 14,
-              value: new Data([
-                // IPv6 unicast
-                0, 2, 1,
-                // Next Hop
-                16, ...ipv6(IPV6_NEXT_HOP).data,
-                // No SNPAs
-                0,
-                // NLRI
-                ...config.ipv6.reachable.flatMap(a => ipv6Prefix(a)),
-              ]),
-              optional: true,
-            },
-            {
-              // MP_UNREACH_NLRI
-              code: 15,
-              value: new Data([
-                // IPv6 unicast
-                0, 2, 1,
-                // NLRI
-                ...config.ipv6.unreachable.flatMap(a => ipv6Prefix(a)),
-              ]),
-              optional: true,
-            }
-          ],
+          pathAttributes,
           withdrawnRoutes: [],
           destinations: [],
         }
diff --git a/src/api/bgp.cpp b/src/api/bgp.cpp
@@ -205,26 +205,13 @@ auto BGP::decode(const Data &data, bool enable_as4) -> pjs::Array* {
 
 void BGP::encode(pjs::Object *payload, bool enable_as4, Data &data) {
   Data payload_buffer;
-
-  pjs::Ref<Message> msg;
-  if (payload && payload->is<Message>()) {
-    msg = payload->as<Message>();
-  } else {
-    msg = Message::make();
-    if (payload) pjs::class_of<Message>()->assign(msg, payload);
-  }
+  pjs::Ref<Message> msg = pjs::coerce<Message>(payload);
 
   if (auto *body = msg->body.get()) {
     Data::Builder db(payload_buffer, &s_dp);
     switch (msg->type.get()) {
       case MessageType::OPEN: {
-        pjs::Ref<MessageOpen> m;
-        if (body->is<MessageOpen>()) {
-          m = body->as<MessageOpen>();
-        } else {
-          m = MessageOpen::make();
-          pjs::class_of<MessageOpen>()->assign(m, body);
-        }
+        pjs::Ref<MessageOpen> m = pjs::coerce<MessageOpen>(body);
         uint8_t ip[4];
         if (!m->identifier || !utils::get_ip_v4(m->identifier->str(), ip)) {
           std::memset(ip, 0, sizeof(ip));
@@ -276,13 +263,7 @@ void BGP::encode(pjs::Object *payload, bool enable_as4, Data &data) {
       }
 
       case MessageType::UPDATE: {
-        pjs::Ref<MessageUpdate> m;
-        if (body->is<MessageUpdate>()) {
-          m = body->as<MessageUpdate>();
-        } else {
-          m = MessageUpdate::make();
-          pjs::class_of<MessageUpdate>()->assign(m, body);
-        }
+        pjs::Ref<MessageUpdate> m = pjs::coerce<MessageUpdate>(body);
         Data withdrawn, path_addr;
         if (auto *a = m->withdrawnRoutes.get()) {
           Data::Builder db(withdrawn, &s_dp);
@@ -357,19 +338,27 @@ void BGP::encode(pjs::Object *payload, bool enable_as4, Data &data) {
       }
 
       case MessageType::NOTIFICATION: {
-        pjs::Ref<MessageNotification> m;
-        if (body->is<MessageNotification>()) {
-          m = body->as<MessageNotification>();
-        } else {
-          m = MessageNotification::make();
-          pjs::class_of<MessageNotification>()->assign(m, body);
-        }
+        pjs::Ref<MessageNotification> m = pjs::coerce<MessageNotification>(body);
         db.push(uint8_t(m->errorCode));
         db.push(uint8_t(m->errorSubcode));
         if (auto *data = m->data.get()) db.push(*data);
         break;
       }
-      default: break;
+
+      case MessageType::ROUTE_REFRESH: {
+        pjs::Ref<MessageRouteRefresh> m = pjs::coerce<MessageRouteRefresh>(body);
+        db.push(uint16_t(m->afi));
+        db.push(uint8_t(0));
+        db.push(uint8_t(m->safi));
+        break;
+      }
+
+      default: {
+        if (body->is<Data>()) {
+          db.push(*body->as<Data>());
+	}
+	break;
+      }
     }
     db.flush();
   }
@@ -435,7 +424,10 @@ auto BGP::Parser::on_state(int state, int c) -> int {
           break;
         case MessageType::KEEPALIVE:
           break;
-        default: error(0, 0); return ERROR;
+        case MessageType::ROUTE_REFRESH:
+          m_message->body = MessageRouteRefresh::make();
+          break;
+        default: break;
       }
       if (size > sizeof(m_header)) {
         m_body->clear();
@@ -461,7 +453,13 @@ auto BGP::Parser::on_state(int state, int c) -> int {
         case MessageType::NOTIFICATION:
           parse_ok = parse_notification(r);
           break;
-        default: break;
+        case MessageType::ROUTE_REFRESH:
+          parse_ok = parse_route_refresh(r);
+          break;
+        default:
+          m_message->body = Data::make(*m_body);
+          parse_ok = true;
+          break;
       }
       if (parse_ok) {
         Deframer::need_flush();
@@ -585,6 +583,23 @@ bool BGP::Parser::parse_notification(Data::Reader &r) {
   return true;
 }
 
+bool BGP::Parser::parse_route_refresh(Data::Reader &r) {
+  auto *body = m_message->body->as<MessageRouteRefresh>();
+
+  uint16_t afi;
+  uint8_t reserved;
+  uint8_t safi;
+
+  if (!read(r, afi)) return false;
+  if (!read(r, reserved)) return false;
+  if (!read(r, safi)) return false;
+
+  body->afi = afi;
+  body->safi = safi;
+
+  return true;
+}
+
 bool BGP::Parser::error(int code, int subcode) {
   pjs::Ref<MessageNotification> msg(MessageNotification::make(code, subcode));
   on_message_error(msg);
@@ -845,6 +860,7 @@ template<> void EnumDef<BGP::MessageType>::init() {
   define(BGP::MessageType::UPDATE, "UPDATE");
   define(BGP::MessageType::NOTIFICATION, "NOTIFICATION");
   define(BGP::MessageType::KEEPALIVE, "KEEPALIVE");
+  define(BGP::MessageType::ROUTE_REFRESH, "ROUTE_REFRESH");
 }
 
 //
@@ -906,7 +922,25 @@ template<> void ClassDef<BGP::PathAttribute>::init() {
 //
 
 template<> void ClassDef<BGP::Message>::init() {
-  field<EnumValue<BGP::MessageType>>("type", [](BGP::Message *obj) { return &obj->type; });
+  accessor("type",
+    [](Object *obj, Value &ret) {
+      auto t = obj->as<BGP::Message>()->type;
+      auto s = EnumDef<BGP::MessageType>::name(t);
+      if (!s) {
+        ret.set((int)t);
+      } else {
+        ret.set(s);
+      }
+    },
+    [](Object *obj, const Value &val) {
+      if (val.is_string()) {
+        obj->as<BGP::Message>()->type = EnumDef<BGP::MessageType>::value(val.s());
+      } else {
+        obj->as<BGP::Message>()->type = (BGP::MessageType)val.to_int32();
+      }
+    }
+  );
+
   field<Ref<Object>>("body", [](BGP::Message *obj) { return &obj->body; });
 }
 
@@ -942,4 +976,13 @@ template<> void ClassDef<BGP::MessageNotification>::init() {
   field<Ref<pipy::Data>>("data", [](BGP::MessageNotification *obj) { return &obj->data; });
 }
 
+//
+// BGP::MessageRouteRefresh
+//
+
+template<> void ClassDef<BGP::MessageRouteRefresh>::init() {
+  field<int>("afi", [](BGP::MessageRouteRefresh *obj) { return &obj->afi; });
+  field<int>("safi", [](BGP::MessageRouteRefresh *obj) { return &obj->safi; });
+}
+
 } // namespace pjs
diff --git a/src/api/bgp.hpp b/src/api/bgp.hpp
@@ -52,6 +52,7 @@ class BGP : public pjs::ObjectTemplate<BGP> {
     UPDATE = 2,
     NOTIFICATION = 3,
     KEEPALIVE = 4,
+    ROUTE_REFRESH = 5,
   };
 
   //
@@ -166,6 +167,25 @@ class BGP : public pjs::ObjectTemplate<BGP> {
     friend class pjs::ObjectTemplate<MessageNotification>;
   };
 
+
+  //
+  // BGP::MessageRouteRefresh
+  //
+
+  class MessageRouteRefresh : public pjs::ObjectTemplate<MessageRouteRefresh> {
+  public:
+    int afi = 0;
+    int safi = 0;
+
+  private:
+    MessageRouteRefresh() {}
+    MessageRouteRefresh(int af, int saf)
+      : afi(af)
+      , safi(saf) {}
+
+    friend class pjs::ObjectTemplate<MessageRouteRefresh>;
+  };
+
   //
   // BGP::Parser
   //
@@ -205,6 +225,7 @@ class BGP : public pjs::ObjectTemplate<BGP> {
     bool parse_open(Data::Reader &r);
     bool parse_update(Data::Reader &r);
     bool parse_notification(Data::Reader &r);
+    bool parse_route_refresh(Data::Reader &r);
     bool error(int code, int subcode);
 
     bool read(Data::Reader &r, Data &data, size_t size);
