Message processing method, communication node and storage medium

Abstract

The present application provides a message processing method, a communication node and a storage medium. The method comprises: on the basis of fixed-length unit bit index explicit replication, encapsulating transmission path information in a message, the fixed-length unit bit index explicit replication comprising a fixed-length unit, and the fixed-length unit comprising a node bit forwarding router identifier (BFR-ID) and a node replication forwarding bit string of a corresponding node; and sending the message.

Description

Message processing method, communication node and storage medium Technical Field

[0001] The present application relates to the field of network communication technology, for example, to a message processing method, a communication node and a storage medium. Background Art

[0002] In an ad hoc network, connections between nodes are not fixed and do not rely on an existing network architecture. The network topology often changes dynamically as nodes move around. Nodes can forward network encapsulated messages to other nodes, but their interdependence is minimal. This type of network is currently widely used in the computer and wireless fields, and has been widely deployed in aircraft, ships, and connected vehicles.

[0003] Ad Hoc networks host a wide range of multicast scenarios. Traditional multicast technologies, such as Protocol Independent Multicast (PIM), require not only that each node run PIM, maintain multicast tree state, and rely on periodic join messages to establish and maintain the multicast tree, but also that routing protocols establish the underlying topology. Once the topology changes, PIM must reestablish the multicast tree through join / leave messages after the entire network's routing protocols have converged. This overhead is completely inadequate for the dynamic nature of Ad Hoc network topologies. Several other multicast technologies exist, but they all suffer from strong inter-node dependencies. Once the network topology changes, routing protocols must notify and calculate these changes, updating forwarding tables before forwarding can resume. Dynamic network topology changes also complicate global planning and place significant demands on node processing power within Ad Hoc networks.

[0004] Summary of the Invention

[0005] The present application provides a message processing method, a communication node and a storage medium.

[0006] This embodiment of the present application provides a message processing method, including:

[0007] Encapsulating the transmission path information in the message based on fixed-length unit bit index explicit replication, wherein the fixed-length unit bit index explicit replication includes a fixed-length unit, and the fixed-length unit includes a node bit forwarding router identifier BFR-ID of a corresponding node and a node replication forwarding bit string;

[0008] Send the message.

[0009] The present application also provides a message processing method, including:

[0010] receiving a message, wherein the message includes transmission path information encapsulated based on a fixed-length unit bit index explicit copy, wherein the fixed-length unit bit index explicit copy includes a fixed-length unit, and the fixed-length unit includes a node bit forwarding router identifier of a corresponding node and a node copy forwarding bit string;

[0011] Determine the node's replication and forwarding bit string based on the fixed-length unit corresponding to the node;

[0012] The message is processed according to the local node's copied and forwarded bit string.

[0013] An embodiment of the present application further provides a communication node, comprising: a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor implements the above-mentioned message processing method when executing the program.

[0014] An embodiment of the present application further provides a computer-readable storage medium, on which a computer program is stored, and when the program is executed by a processor, the above-mentioned message processing method is implemented. BRIEF DESCRIPTION OF THE DRAWINGS

[0015] FIG1 is a schematic diagram of a network corresponding to a multicast scenario provided by an embodiment;

[0016] FIG2 is a flow chart of a message processing method provided by an embodiment;

[0017] FIG3 is a flow chart of another message processing method provided by an embodiment;

[0018] FIG4 is a schematic diagram of a network hierarchy provided by an embodiment;

[0019] FIG5 is a schematic diagram of a FUBIER provided by an embodiment;

[0020] FIG6 is a schematic diagram of a fixed-length unit provided by an embodiment;

[0021] FIG7 is a schematic diagram of a node replicating and forwarding a bit string provided by an embodiment;

[0022] FIG8 is a schematic diagram of a multicast path based on FUBIER encapsulation provided by an embodiment;

[0023] FIG9 is a schematic diagram of fixed-length units of each node provided by an embodiment;

[0024] FIG10 is a schematic diagram of another network hierarchy provided by an embodiment;

[0025] FIG11 is a schematic structural diagram of a message processing device provided by an embodiment;

[0026] FIG12 is a schematic structural diagram of another message processing device provided by an embodiment;

[0027] FIG13 is a schematic diagram of the hardware structure of a communication node provided by an embodiment. DETAILED DESCRIPTION

[0028] The present application is described below in conjunction with the accompanying drawings and embodiments. It will be understood that the specific embodiments described herein are merely intended to explain the present application and are not intended to limit the present application. It should be noted that, unless there is a conflict, the embodiments and features within the embodiments of the present application may be combined with each other in any manner. It should also be noted that, for ease of description, the accompanying drawings only illustrate portions relevant to the present application, not all structures.

[0029] Figure 1 is a schematic diagram of a network corresponding to a multicast scenario provided by an embodiment. As shown in Figure 1, traffic can be forwarded from node A of the network through nodes B, C, D, E, F, G, H, K, M, N, etc. to the receiving end that needs the traffic. Among them, there is a shared network between nodes G, M and N. If Bit Indexed Explicit Replication (BIER) is applied to this network, node A acts as the entry node of the Bit Forwarding Ingress Router (BFIR) to encapsulate the traffic with a BIER header. The bit string (BitString) in the BIER header needs to identify the exit (connection receiver) nodes C, D, F, H, K, M and N. The encapsulated message will be forwarded in this network by searching the BIER forwarding table at each node. When forwarding to the next node, each node also needs to encapsulate the BIER forwarding table index required by the next node in the BIER header. Before the ingress node encapsulates the message, the network needs to establish the underlying topology through the routing protocol, and pass the Bit Forwarding Router-Identifier (BFR-ID) and BIER forwarding table index of each node, so that each node can form a BIER forwarding table leading to all other nodes in the network and obtain the BIER forwarding table index required by the next node. Once the network topology changes, the routing protocol needs to announce and calculate these changes, and update the BIER forwarding routing table before normal forwarding can continue; therefore, there is a strong dependency between the nodes, and it is actually impossible to directly apply BIER technology to this network.

[0030] Compared with BIER, BIER Tree Engineering (BIER-TE) has a weaker dependence on routing protocols, but requires global planning of link bit positions (Bit-Position). In Ad Hoc networks, because the topology changes dynamically, global planning is very difficult, so BIER-TE technology cannot be directly applied to the network.

[0031] This application defines a Fixed Unit Bit Indexed Explicit Replication (FUBIER) technology that can forward traffic along a multicast path in Ad Hoc networks and ordinary conventional networks, and has the characteristics of being stateless, low-dependency, simple and efficient.

[0032] FIG2 is a flowchart of a message processing method provided by one embodiment. This method can be applied to a first communication node, such as an entry node, source node, root node, or message sender in a network. The first communication node can encapsulate and send a message. As shown in FIG2 , the method provided by this embodiment includes steps 110 and 120.

[0033] In step 110, the transmission path information is encapsulated in a message based on fixed-length unit bit index explicit replication, wherein the fixed-length unit bit index explicit replication includes a fixed-length unit including a node bit forwarding router identifier BFR-ID of a corresponding node and a node replication forwarding bit string.

[0034] In step 120, the message is sent.

[0035] In this embodiment, fixed-length units are used to reflect the transmission path of messages between different nodes. FUBIER usually includes multiple fixed-length units, each of which is used to indicate the BFR-ID of the corresponding node and the node replication and forwarding bit string. Each bit in the node replication and forwarding bit string corresponds to an interface of the node that needs to replicate and forward the message. On this basis, the encapsulated information can be easily adjusted when the network topology changes, which can reduce the dependency between nodes. The length of the fixed-length unit can be 32 bits, 64 bits, 96 bits, 128 bits, etc. The length of each information in the fixed-length unit can be adjusted according to the actual networking, and the position of each information can also be adjusted according to the implementation situation. Generally, the encapsulation and processing methods of each node in a network are unified. FUBIER can be encapsulated in the BitString position in the BIER header, or it can be encapsulated separately following Ethernet, IPv4, IPv6, etc. This embodiment does not impose any restrictions on this.

[0036] In one embodiment, the node copy forwarding bit string includes a local decapsulation flag, which is used to indicate whether the corresponding node decapsulates the message. The local decapsulation flag may also be called a local decapsulation flag or a local node decapsulation flag.

[0037] In one embodiment, the local decapsulation flag is the lowest or highest bit of the node copy and forwarding bit string. The local decapsulation flag of each node can be unified as the lowest or highest bit of the bit string.

[0038] In one embodiment, the fixed-length unit also includes level information of the corresponding node, and the level information is used to indicate the level to which the corresponding node belongs.

[0039] In one embodiment, the method further comprises:

[0040] Obtain a forwarding table for each node in the network, wherein the forwarding table includes the node interface and interface index;

[0041] The transmission path information is determined according to the forwarding table of each node.

[0042] In this embodiment, before encapsulating a message, each node may generate a forwarding table based on its interfaces and interface indexes. The forwarding table includes the interface index and specific interface, and may also include the neighbors connected to the interface. The first communication node determines the multicast path in the network based on the forwarding table of each node and encapsulates the message using a fixed-length unit bit index explicit replication format.

[0043] In one embodiment, the forwarding table also includes neighbor nodes of the interface of the current node.

[0044] In one embodiment, the transmission path information is explicitly copied and encapsulated in an Ethernet header or an IPv4 / IPv6 header based on a fixed-length unit bit index, or is carried by options in an IPv6 hop-by-hop options header extension header or a destination options extension header.

[0045] The above message processing method can make the nodes basically independent of each other and the routing protocol. Whether it is implemented in software or hardware chips, it can achieve simple logic and efficient processing. In addition to Ad Hoc networks, it is also applicable to conventional networks.

[0046] FIG3 is a flow chart of another message processing method provided by an embodiment, which can be applied to a second communication node, which can be a node that forwards messages or a receiving end of messages. As shown in FIG3 , the method provided by this embodiment includes:

[0047] In step 210, a message is received, wherein the message includes transmission path information encapsulated based on a fixed-length unit bit index explicit copy, wherein the fixed-length unit bit index explicit copy includes a fixed-length unit, and the fixed-length unit includes a node bit forwarding router identifier of a corresponding node and a node copy forwarding bit string.

[0048] In step 220, the node's copy and forwarding bit string is determined based on the fixed-length unit corresponding to the node.

[0049] In step 230, the message is processed according to the local node's copied and forwarded bit string.

[0050] In this embodiment, upon receiving a message containing transmission path information explicitly replicated and encapsulated based on fixed-length unit bit indices, each node can search the fixed-length unit containing its own node's BFR-ID, obtain its own replicated forwarding bit string, and, based on its own replicated forwarding bit string, determine whether to decapsulate the message and forward it to the recipient. It also checks whether there is an interface index requiring forwarding. If so, it replicates and forwards the message based on its own forwarding table. If no interface index requiring forwarding exists, forwarding is terminated. Furthermore, if the fixed-length unit containing its own node's BFR-ID cannot be found, the node can log an error, discard the message, and so on.

[0051] In one embodiment, the local node's copied and forwarded bit string includes a local decapsulation flag; and processing the message based on the local node's copied and forwarded bit string includes: if the local decapsulation flag is a specified value, decapsulating the message and forwarding the message to the local node's receiver. For example, determining whether the local decapsulation flag is set to 1, and if so, decapsulating the message and forwarding it to the receiver.

[0052] In one embodiment, the local decapsulation flag is the lowest bit or the highest bit of the node copy forwarding bit string.

[0053] In one embodiment, processing the message according to the local node's copy and forward bit string includes:

[0054] In the case that the interface index to be forwarded exists in the copied forwarding bit string of the local node, the message is copied and forwarded to the next hop node according to the forwarding table of the local node.

[0055] In one embodiment, the fixed-length unit also includes level information of the corresponding node, and the level information is used to indicate the level to which the corresponding node belongs.

[0056] In one embodiment, the method further includes: determining the hierarchical information in the fixed-length unit of the neighboring node; when the hierarchical information of the neighboring node is one level higher than the hierarchical information of the current node, the hierarchical information of the neighboring node passes the verification.

[0057] In this embodiment, the next-hop node's hierarchical information can be checked to see if it is correct. The hierarchical information of the next-hop node to be forwarded should be one level higher than the current node's. If the next-hop node's hierarchical information is incorrect, the message is not forwarded to that next-hop node. It should be noted that in a shared network, this check may not be necessary, or it may not be necessary to check all next-hop nodes.

[0058] In one embodiment, before processing the message according to the copied and forwarded bit string of the current node, the method also includes: deleting the fixed-length unit corresponding to the specified node in the explicit replication of the fixed-length unit bit index, and the specified node includes a node whose hierarchical information is equal to or lower than the hierarchical information of the current node.

[0059] In this embodiment, before forwarding the message to the next hop node, the fixed-length units in the fixed-length unit bit index explicit copy encapsulation at a level equal to or lower than the level of this node can be deleted, thereby reducing the search time of the next hop node and subsequent nodes and improving the message processing efficiency.

[0060] In one embodiment, the method further comprises:

[0061] Generate the forwarding table of this node based on the interface and interface index of this node.

[0062] In one embodiment, the forwarding table also includes neighbor nodes of the interface of the current node.

[0063] In one embodiment, the transmission path information is explicitly copied and encapsulated in an Ethernet header or an IPv4 / IPv6 header based on a fixed-length unit bit index, or is carried by options in an IPv6 hop-by-hop options header extension header or a destination options extension header.

[0064] The message processing method of the present application is exemplified below through some embodiments.

[0065] Example 1

[0066] Figure 4 is a schematic diagram of a network hierarchy provided by one embodiment. Taking the network shown in Figure 1 as an example, nodes can be divided into several hierarchical levels based on their distance from the root node. As shown in Figure 4, node A is the root node and is at Level 0. Nodes B, C, and D are at Level 1, nodes E, F, and G are at Level 2, and nodes H, K, M, and N are at Level 3. Nodes C, D, F, H, K, M, and N are connected to multicast traffic receivers.

[0067] Multicast paths are encapsulated using FUBIER. Each fixed-length unit contains the node's BFR-ID and the node's replication bit string. Each bit in the node's replication bit string corresponds to an interface on the node that needs to replicate and forward the message. The lowest bit in the node's replication bit string serves as a universal decapsulation flag for the node. If the decapsulation flag in a node's replication bit string is set, it indicates that the node has a local receiver and needs to decapsulate the message. This means that the fixed-length unit bit index is removed, the message is explicitly replicated, and then sent to the local receiver.

[0068] Figure 5 is a schematic diagram of a FUBIER provided by an embodiment. As shown in Figure 5, FUBIER identifies a multicast path as a series of fixed-length units (abbreviated as units), and each node involved in the entire multicast path can be identified by a fixed-length unit.

[0069] Figure 6 is a schematic diagram of a fixed-length unit provided by an embodiment. The length of the fixed-length unit can be determined according to the complexity of the nodes in the network, such as 32 bits, 64 bits, 96 bits, 128 bits, etc.; each fixed-length unit contains the BFR-ID of the node and the node copy forwarding bit string (Fwd-BitString, also known as the interface forwarding bit string Intf-BitString) information or elements of the node, and optionally contains level information or elements. In the simplest implementation, the level element may not be included. The position of each element in the fixed-length unit can be exchanged according to the implementation situation, and the length of each element can be fixed, such as the fixed-length unit length is 32 bits, of which the BFR-ID is represented by 16 bits, the level information is represented by 4 bits, and the node copy forwarding bit string is represented by 12 bits.

[0070] Figure 7 is a schematic diagram of a node replication forwarding bit string provided by one embodiment. As shown in Figure 7, in addition to the node interface forwarding bit string (Intf-BitString), it also includes the node decapsulation identifier (Decap). Each node can uniformly use the lowest or highest bit as the node decapsulation identifier. Figure 7 shows the lowest bit as the node decapsulation identifier. Each bit in the node replication forwarding bit string corresponds to a local interface of the corresponding node. If the corresponding bit is set (set to 1), it indicates that the message needs to be forwarded from the local interface.

[0071] Before encapsulating a message at the ingress, or root node, each node configures its own BFR-ID (each node's BFR-ID value is unique) and generates its own forwarding table, as shown in Table 1. If the bit corresponding to the index value is set to 1 in the node's replicated forwarding bit string, it indicates that the message needs to be forwarded from the interface corresponding to the index value. The forwarding table is only relevant to the local interface and has no bearing on the direction of traffic, making it a stateless forwarding table. Table 2 shows the forwarding table for node A, Table 3 shows the forwarding table for node B, and Table 4 shows the forwarding table for node C. This forwarding table is only relevant to the node's interface connectivity and has no bearing on traffic flow.

[0072] Table 1: This node's forwarding table

[0073] Table 2 Node A forwarding table

[0074] Table 3 Node B forwarding table

[0075] Table 4 Node C forwarding table

[0076] Figure 8 is an example of encapsulating the multicast path shown in Figure 4 using FUBIER technology. All forwarding nodes involved in the traffic are encapsulated in fixed-length units. All units can be used as BitStrings in the BIER header and carried by the BIER header, or they can be separated from the BIER header and directly represented by a specific Ethernet type or IPv4 / IPv6 protocol type. In this way, FUBIER can directly follow the Ethernet header or IPv4 / IPv6 header, and can even be carried as an option in the IPv6 Hop-by-Hop Options Header (HBH) extension header or the Destination Options Header (DOH). This application does not impose any restrictions here.

[0077] Figure 9 illustrates the fixed-length units of each node in sequence. Node A's fixed-length unit contains its BFR-ID and its own level information, which is 0. Because this node has no receivers, the node's local decapsulation flag in its replication bit string is not set (set to 0). The corresponding bits in the node forwarding replication bit string corresponding to interfaces 1, 2, and 3 (corresponding to the interfaces sent to nodes B, C, and D) are set (set to 1). After the message is replicated, it is sent out from interfaces 1, 2, and 3, respectively. Node B's fixed-length unit contains its BFR-ID and level information. Interfaces 2 and 4 connected to nodes E and F have their corresponding bits set in its replication bit string. Similarly, because this node has no receivers, the node's local decapsulation flag in its replication bit string is not set. Node C's fixed-length unit contains node C's BFR-ID and layer information. Because this node has a receiver but no interfaces requiring further forwarding, the local decapsulation bit in this node's replicated forwarding bit string is set. All bits corresponding to other interfaces in the replicated forwarding bit string are unset, i.e., all 0s. Node D's fixed-length unit contains node D's BFR-ID and layer information. Because this node has a receiver and an interface requiring forwarding, the local decapsulation bit in this node's replicated forwarding bit string is set, and the bit corresponding to interface 9 in the replicated forwarding bit string is set. Node E's fixed-length unit contains node E's BFR-ID and layer information. Bits 6 and 8 corresponding to interfaces connected to H and K in this node's replicated forwarding bit string are set. The fixed-length unit encapsulation logic for nodes F, G, H, etc. is similar.

[0078] The node's processing flow for FUBIER-encapsulated messages includes: first searching the unit where the node is located, that is, searching for the unit whose BFR-ID value is consistent with that of the node, obtaining the node's copy and forwarding bit string information (and hierarchical information), and if the node's decapsulation flag is set, decapsulating the message, removing the entire FUBIER encapsulation and forwarding it to the receiver. If the copied bit string is not all 0, indicating that there is an interface index that needs to be forwarded, the node's forwarding table is searched, and the copied message is sent from the interface corresponding to the set index.

[0079] As shown in Figure 4, upon receiving a FUBIER-encapsulated message, the forwarding engine of node A searches for a unit with the same BFR-ID as its own node. If it cannot find one, it discards the message. Upon finding its own unit, it determines that bits 1, 2, and 3, starting from the lowest bit in the copy-forwarding bit string (excluding the decapsulation flag), are set, indicating that the message needs to be replicated and forwarded from interfaces 1, 2, and 3. Therefore, it copies the message three times and sends them out of interfaces 1, 2, and 3, respectively. Upon receiving a FUBIER-encapsulated message, node B finds its own unit and, based on the bit settings in its own copy-forwarding bit string, determines that bits 2 and 4, starting from the lowest bit in the copy-forwarding bit string (excluding the decapsulation flag), are set. It then replicates the message and sends it out of interfaces 2 and 4. When node C receives a FUBIER-encapsulated message, it locates its own node unit and, based on the bit settings in its own replicated forwarding bit string, discovers that no bits are set except the decapsulation flag. Therefore, it decapsulates the message, removes the entire FUBIER encapsulation, and forwards it to the receiver. When node D receives a FUBIER-encapsulated message, it locates its own node unit and, based on the bit settings in its own replicated forwarding bit string, discovers that bit 9 is set in addition to the decapsulation flag. It then copies the message and sends it out of interface 9, decapsulates the message, removes the entire FUBIER encapsulation, and forwards it to the receiver. The other nodes follow a similar process, ultimately reaching all receivers and completing forwarding along the entire multicast path.

[0080] In the network shown in FIG4 , a fixed-length unit of 32 bits, that is, 4 bytes, is used to implement the multicast path with 11 nodes. The final encapsulated FUBIER length is 44 bytes, which occupies a small number of bytes and is simple and efficient to process.

[0081] In some networks, each node may have a large number of interfaces. In this case, fixed-length units such as 64 or 96 bits can be used to increase the number of bits used in the node's replicated and forwarded bit strings. This is not detailed here.

[0082] Figure 10 is a schematic diagram of another network hierarchy provided by one embodiment. As shown in Figure 10, a traffic stream enters through node H, passes through nodes E, B, A, C, and D, and is received by the receivers at nodes C and D. Similarly, based on the distance from entry node H, it is determined that node E is a first-level node, node B is a second-level node, node A is a third-level node, and nodes C and D are fourth-level nodes. After the units of these nodes are encapsulated using the FUBIER method, they are processed at each hop and ultimately reach the receiver. This process eliminates the need for each node to maintain state based on the multicast stream; it can be achieved solely based on its own forwarding table.

[0083] The multicast path requires the BFR-ID, interface, and index information of each node. This information can be obtained directly from each node by the controller or ingress / root node, or announced through protocol extensions, such as Ad Hoc network routing protocols such as Ad Hoc On-Demand Distance Vector (AODV) and Optimized Link State Routing (OLSR). When FUBIER technology is applied to conventional bearer networks, it can also be announced through extended protocols such as OSPF (Open Shortest Path First), Intermediate System-to-Intermediate System (IS-IS), Border Gateway Protocol (BGP), Routing in Fat Trees (RIFT), or BABEL. Because a node's BFR-ID and interface information do not change with network topology changes caused by node movement, it has little dependency on routing protocols.

[0084] Example 2

[0085] Based on the above embodiment, assuming that the FUBIER encapsulation of the node contains hierarchical elements and the forwarding table of the node contains neighbor node information as shown in Table 1, hierarchical verification can be implemented to avoid forwarding incorrectly encapsulated messages.

[0086] Specifically, when a node receives a FUBIER-encapsulated message, it locates its cell, obtains its own hierarchy information and the replicated forwarding bit string, and then searches the forwarding table based on the bits set in the replicated forwarding bit string. This allows it to locate not only the local interface but also the corresponding neighbor information. The node then uses the neighbor's BFR-ID to locate its cell within the FUBIER encapsulation, obtain its hierarchy information, and compare the neighbor's hierarchy with its own. If the neighbor's hierarchy information is one level higher than the node's, the verification passes. If not, the encapsulation is incorrect, potentially a forged message, which could lead to loops and other risks. In this case, the error is recorded and the message is discarded without forwarding.

[0087] If the neighbor unit cannot be found, it also indicates that there is an encapsulation error. The error will also be recorded and the message will be discarded and no longer forwarded.

[0088] For example, node B in Figure 4 receives a FUBIER-encapsulated message, finds the unit where this node is located, and obtains the node's level information as 1. Based on the setting status of the copy and forward bit string, it finds that the message is to be copied and sent from interfaces 2 and 4. When searching the forwarding table, it can be obtained that the neighbors corresponding to interfaces 2 and 4 are nodes E and F. Before copying and forwarding the message, node B uses the BFR-ID of nodes E and F to search for the FUBIER encapsulation. After obtaining the units of nodes E and F respectively, it checks the level information of nodes E and F to see if it is 2. If so, the verification passes, and node B copies the message and sends it from interfaces 2 and 4. If not, it indicates an encapsulation error, and continuing to forward may cause risks such as loops. At this time, the error can be recorded, and the message can be discarded and no longer forwarded.

[0089] It's important to note that assuming a shared network exists on the multicast path, meaning that any message sent by any node on this network can be received by all other nodes, hierarchical verification is unnecessary. Alternatively, all neighbors can be verified, but only one node needs to pass hierarchical verification for normal forwarding. For example, in Figure 4, nodes G, M, and N share a network. In the forwarding tables of nodes G, M, and N, one interface corresponds to multiple neighbors. Assuming node N has no receivers, the corresponding unit for node N cannot be found in the FUBIER encapsulation. However, node M passes verification, so the message still needs to be forwarded normally, rather than discarded.

[0090] Example 3:

[0091] Based on the above embodiment, assuming that the FUBIER encapsulation of the node contains hierarchical elements, each node can delete the units in the FUBIER encapsulation that are at the same level as the node or at a lower level than the node (that is, closer to the root node than the node) before searching the forwarding table and preparing to forward from the corresponding interface. In this way, the next-level node can find the corresponding unit more quickly and process it.

[0092] For example, in Figure 4, before node A finds a message that needs to be forwarded out of interfaces 1 / 2 / 3 at the forwarding level, it deletes any elements from the FUBIER encapsulation that are at or below its own level. In this example, it deletes node A's elements. This way, when the message is sent to nodes B, C, and D, the FUBIER encapsulation will no longer contain node A's elements. Taking node B as an example, before node B processes the message and finds that it needs to be forwarded out of interfaces 2 / 4, it similarly deletes any elements from the FUBIER encapsulation that are at or below its own level. Specifically, it deletes elements from nodes B, C, and D. This way, when the message is forwarded to the next-level nodes E and F, the FUBIER encapsulation will no longer contain elements from nodes A, B, C, and D. This allows the next-level nodes to avoid searching for elements at a lower level than their own, speeding up processing and improving efficiency.

[0093] The FUBIER encapsulation and processing method in any of the above embodiments not only does not have a multicast tree state, but also does not rely on each other between nodes and does not need to rely on routing protocols, and can simply and efficiently implement multicast forwarding in Ad Hoc networks and conventional networks.

[0094] The present application also provides a message processing device. FIG11 is a schematic diagram of the structure of a message processing device provided by an embodiment. As shown in FIG11, the message processing device includes:

[0095] an encapsulation module 310 configured to encapsulate the transmission path information in a message based on a fixed-length unit bit index explicit replication, wherein the fixed-length unit bit index explicit replication includes a fixed-length unit, and the fixed-length unit includes a node bit forwarding router identifier BFR-ID of a corresponding node and a node replication forwarding bit string;

[0096] The sending module 320 is configured to send the message.

[0097] In one embodiment, the node copy-forward bit string includes a local decapsulation flag, and the local decapsulation flag is used to indicate whether the corresponding node decapsulates the message.

[0098] In one embodiment, the local decapsulation flag is the lowest bit or the highest bit of the node copy forwarding bit string.

[0099] In one embodiment, the fixed-length unit also includes level information of the corresponding node, and the level information is used to indicate the level to which the corresponding node belongs.

[0100] In one embodiment, the method further comprises:

[0101] Obtain a forwarding table for each node in the network, wherein the forwarding table includes the node interface and interface index;

[0102] The transmission path information is determined according to the forwarding table of each node.

[0103] In one embodiment, the forwarding table also includes neighbor nodes of the interface of the current node.

[0104] The message processing device proposed in this embodiment and the message processing method proposed in the above embodiment belong to the same inventive concept. Technical details not fully described in this embodiment can be referred to any of the above embodiments, and this embodiment has the same beneficial effects as executing the message processing method.

[0105] The present application also provides a message processing device. FIG12 is a schematic diagram of the structure of another message processing device provided by an embodiment. As shown in FIG12, the message processing device includes:

[0106] A message receiving module 410 is configured to receive a message, wherein the message includes transmission path information encapsulated based on a fixed-length unit bit index explicit replication, wherein the fixed-length unit bit index explicit replication includes a fixed-length unit, and the fixed-length unit includes a node bit forwarding router identifier of a corresponding node and a node replication forwarding bit string;

[0107] A determination module 420 is configured to determine a copy and forwarding bit string of the node according to a fixed-length unit corresponding to the node;

[0108] The processing module 430 is configured to process the message according to the local node's copied and forwarded bit string.

[0109] In one embodiment, the local node's copied and forwarded bit string includes a local decapsulation identifier;

[0110] The processing module 430 is configured to:

[0111] When the local decapsulation identifier is a specified value, the message is decapsulated and forwarded to a receiver of the local node.

[0112] In one embodiment, the local decapsulation flag is the lowest bit or the highest bit of the node copy forwarding bit string.

[0113] In one embodiment, the processing module 430 is configured to:

[0114] In the case that the interface index to be forwarded exists in the copied and forwarded bit string of the local node, the message is copied and forwarded to the next hop node according to the forwarding table of the local node.

[0115] In one embodiment, the fixed-length unit also includes level information of the corresponding node, and the level information is used to indicate the level to which the corresponding node belongs.

[0116] In one embodiment, the apparatus further comprises:

[0117] a level determination module configured to determine level information in fixed-length units of neighboring nodes;

[0118] The verification module is configured to verify that the level information of the neighboring node passes the verification when the level information of the neighboring node is one level higher than the level information of the current node.

[0119] In one embodiment, before processing the message according to the local node copy and forward bit string, the apparatus further includes:

[0120] The deletion module is configured to delete the fixed-length unit corresponding to the specified node in the explicit replication of the fixed-length unit bit index, and the specified node includes a node whose level information is equal to or lower than the level information of the current node.

[0121] In one embodiment, the apparatus further comprises:

[0122] The generation module is configured to generate a forwarding table of the node according to the interface and interface index of the node.

[0123] In one embodiment, the forwarding table also includes neighbor nodes of the interface of the current node.

[0124] The message processing device proposed in this embodiment and the message processing method proposed in the above embodiment belong to the same inventive concept. Technical details not fully described in this embodiment can be referred to any of the above embodiments, and this embodiment has the same beneficial effects as executing the message processing method.

[0125] An embodiment of the present application also provides a communication node. Figure 13 is a schematic diagram of the hardware structure of a communication node provided by an embodiment. As shown in Figure 13, the communication node provided by the present application includes a processor 510 and a memory 520; the processor 510 in the communication node can be one or more, and Figure 13 takes one processor 510 as an example; the memory 520 is configured to store one or more programs; the one or more programs are executed by the one or more processors 510, so that the one or more processors 510 implement the message processing method as described in the embodiment of the present application.

[0126] The communication node further includes: a communication device 530 , an input device 540 and an output device 550 .

[0127] The processor 510, memory 520, communication device 530, input device 540 and output device 550 in the communication node may be connected via a bus or other means. FIG13 takes the bus connection as an example.

[0128] The input device 540 may be used to receive input digital or character information and generate key signal input related to user settings and function control of the communication node. The output device 550 may include a display device such as a display screen.

[0129] The communication device 530 may include a receiver and a transmitter. The communication device 530 is configured to perform information transmission and reception communication according to the control of the processor 510.

[0130] The memory 520, as a computer-readable storage medium, can be configured to store software programs, computer executable programs, and modules, such as program instructions / modules corresponding to the message processing method described in the embodiment of the present application (for example, the encapsulation module 310 and the sending module 320 in the message processing device). The memory 520 may include a program storage area and a data storage area, wherein the program storage area may store an operating system, an application required for at least one function; the data storage area may store data created according to the use of the communication node, etc. In addition, the memory 520 may include a high-speed random access memory, and may also include a non-volatile memory, such as at least one disk storage device, a flash memory device, or other non-volatile solid-state storage device. In some instances, the memory 520 may further include a memory remotely arranged relative to the processor 510, and these remote memories may be connected to the communication node via a network. Examples of the above-mentioned network include, but are not limited to, the Internet, an intranet, a local area network, a mobile communication network, and a combination thereof.

[0131] The embodiment of the present application also provides a storage medium, wherein the storage medium stores a computer program, and when the computer program is executed by a processor, it implements the message processing method described in any one of the embodiments of the present application. The method includes: encapsulating the transmission path information in the message based on the explicit replication of the fixed-length unit bit index, the fixed-length unit bit index explicit replication includes a fixed-length unit, and the fixed-length unit includes the node bit forwarding router identifier BFR-ID of the corresponding node and the node replication forwarding bit string; sending the message. Alternatively, the method includes: receiving a message, the message containing the transmission path information encapsulated based on the explicit replication of the fixed-length unit bit index, the fixed-length unit bit index explicit replication includes a fixed-length unit, and the fixed-length unit includes the node bit forwarding router identifier of the corresponding node and the node replication forwarding bit string; determining the node replication forwarding bit string according to the fixed-length unit corresponding to the node; processing the message according to the node replication forwarding bit string.

[0132] The computer storage medium of the embodiment of the present application can adopt any combination of one or more computer-readable media.Computer-readable medium can be a computer-readable signal medium or a computer-readable storage medium.Computer-readable storage medium can be, for example, but not limited to: an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, device or component, or any combination of the above.More specific examples (non-exhaustive list) of computer-readable storage media include: an electrical connection with one or more wires, a portable computer disk, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM), a flash memory, an optical fiber, a portable compact disk read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the above.Computer-readable storage medium can be any tangible medium containing or storing a program, which can be used by an instruction execution system, device or device or used in combination with it.

[0133] A computer-readable signal medium may include a data signal propagated in baseband or as part of a carrier wave, carrying computer-readable program code. Such a propagated data signal may take a variety of forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination thereof. A computer-readable signal medium may also be any computer-readable medium other than a computer-readable storage medium that can transmit, propagate, or transport a program for use by or in conjunction with an instruction execution system, apparatus, or device.

[0134] The program code contained on the computer-readable medium may be transmitted using any appropriate medium, including but not limited to wireless, wire, optical cable, radio frequency (RF), etc., or any suitable combination of the foregoing.

[0135] The computer program code for performing the operations of the present application can be written in one or more programming languages ​​or a combination thereof, including object-oriented programming languages ​​such as Java, Smalltalk, C++, and conventional procedural programming languages ​​such as "C" or similar programming languages. The program code can be executed entirely on the user's computer, partially on the user's computer, as an independent software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In the case of a remote computer, the remote computer can be connected to the user's computer through any type of network, including a local area network (LAN) or a wide area network (WAN), or can be connected to an external computer (e.g., using an Internet service provider to connect via the Internet).

[0136] The above description is merely an exemplary embodiment of the present application and is not intended to limit the scope of protection of the present application.

[0137] It will be appreciated by those skilled in the art that the term user terminal encompasses any suitable type of wireless user equipment, such as a mobile phone, a portable data processor, a portable web browser or a vehicle-mounted mobile station.

[0138] In general, various embodiments of the present application may be implemented in hardware or dedicated circuits, software, logic, or any combination thereof. For example, some aspects may be implemented in hardware, while other aspects may be implemented in firmware or software that can be executed by a controller, microprocessor, or other computing device, although the present application is not limited thereto.

[0139] Embodiments of the present application may be implemented by executing computer program instructions by a data processor of a mobile device, for example, in a processor entity, or by hardware, or by a combination of software and hardware. The computer program instructions may be assembly instructions, instruction set architecture (ISA) instructions, machine instructions, machine-dependent instructions, microcode, firmware instructions, state setting data, or source code or object code written in any combination of one or more programming languages.

[0140] The block diagram of any logical flow in the drawings of this application may represent program steps, or may represent interconnected logical circuits, modules and functions, or may represent a combination of program steps and logical circuits, modules and functions. A computer program may be stored on a memory. The memory may be of any type suitable for the local technical environment and may be implemented using any suitable data storage technology, such as but not limited to read-only memory (ROM), random access memory (RAM), optical storage devices and systems (digital versatile discs (DVD) or compact disks (CD), etc.). Computer-readable media may include non-transitory storage media. The data processor may be of any type suitable for the local technical environment, such as but not limited to a general-purpose computer, a special-purpose computer, a microprocessor, a digital signal processor (DSP), an application-specific integrated circuit (ASIC), a programmable logic device (FPGA) and a processor based on a multi-core processor architecture.

[0141] The above description of exemplary embodiments of the present application has been provided by way of exemplary and non-limiting examples. However, various modifications and adaptations of the above embodiments will be apparent to those skilled in the art, when considered in conjunction with the accompanying drawings and the appended claims, without departing from the scope of the present application. Therefore, the proper scope of the present application will be determined by reference to the appended claims.

Claims

1. A message processing method, applied to a first node, includes: Encapsulating transmission path information in a message based on fixed-length unit bit index explicit replication, where the fixed-length unit bit index explicit replication includes a fixed-length unit, and the fixed-length unit includes a node bit forwarding router identifier (BFR-ID) of a corresponding node and a node replication forwarding bit string; Sending the message.

2. The method according to claim 1, wherein, The node replication forwarding bit string includes a local decapsulation identifier, and the local decapsulation identifier is used to indicate whether the corresponding node decapsulates the message.

3. The method according to claim 2, wherein, The local decapsulation identifier is the lowest bit or the highest bit of the node replication forwarding bit string.

4. The method according to claim 1, wherein The fixed-length unit further includes hierarchical information of the corresponding node, and the hierarchical information is used to indicate the hierarchy to which the corresponding node belongs.

5. The method according to claim 1 further includes: Obtaining the forwarding table of each node in the network, where the forwarding table includes the interfaces of the local node and interface indexes; Determining the transmission path information according to the forwarding table of each node.

6. The method according to claim 4, wherein The forwarding table further includes neighbor nodes of the interfaces of the local node.

7. The method according to claim 1, wherein The transmission path information is encapsulated based on the fixed-length unit bit index explicit replication after an Ethernet header or an IPv4 / IPv6 header, or carried by options in a hop-by-hop options header extension header or a destination options extension message header of IPv6.

8. A message processing method, applied to a second node, includes: Receiving a message, where the message contains transmission path information encapsulated based on fixed-length unit bit index explicit replication, the fixed-length unit bit index explicit replication includes a fixed-length unit, and the fixed-length unit includes a node bit forwarding router identifier and a node replication forwarding bit string of a corresponding node; Determining the node replication forwarding bit string of the local node according to the fixed-length unit corresponding to the local node; Processing the message according to the node replication forwarding bit string of the local node.

9. The method according to claim 8, wherein The node replication forwarding bit string of the local node includes a local decapsulation identifier; Processing the message according to the node replication forwarding bit string of the local node includes: When the local decapsulation identifier is a specified value, decapsulating the message and forwarding the message to the receiver of the local node.

10. The method according to claim 9, wherein, The local decapsulation identifier is the lowest bit or the highest bit of the node replication forwarding bit string.

11. The method according to claim 9, wherein Processing the message according to the node replication forwarding bit string of the local node includes: When there is an interface index to be forwarded in the node replication forwarding bit string of the local node, copying and forwarding the message to the next-hop node according to the forwarding table of the local node.

12. The method according to claim 9, wherein, The fixed-length unit further includes hierarchical information of the corresponding node, and the hierarchical information is used to indicate the hierarchy to which the corresponding node belongs.

13. The method according to claim 12 further includes: Determining the hierarchical information in the fixed-length unit of a neighbor node; When the hierarchical information of the neighbor node is one level higher than the hierarchical information of the local node, the hierarchical information of the neighbor node passes the verification.

14. Before processing the message according to the node replication forwarding bit string of the local node, the method according to claim 12 further includes: Deleting the fixed-length unit corresponding to a specified node in the fixed-length unit bit index explicit replication, where the specified node includes nodes with hierarchical information equal to or lower than the hierarchical information of the local node.

15. The method according to claim 9 further comprises: generating a forwarding table of this node according to this node interface and the interface index.

16. The method according to claim 15, wherein the forwarding table further comprises neighbor nodes of this node interface.

17. The method according to claim 8, wherein The transmission path information is explicitly replicated and encapsulated after the Ethernet header or the IPv4 / IPv6 header based on the fixed-length cell bit index, or carried by options in the hop-by-hop options header extension header or the destination options extension message header of IPv6.

18. A communication node, comprising: a memory, and one or more processors; the memory is configured to store one or more programs; when the one or more programs are executed by the one or more processors, the one or more processors implement the packet processing method according to any one of claims 1-17.

19. A computer-readable storage medium having a computer program stored thereon, wherein, When the program is executed by a processor, it implements the packet processing method according to any one of claims 1-18.

Images