/*++ Copyright (c) 1997 Microsoft Corporation Module Name: strie.c Abstract: This module contains routines that manipulate an S-trie data stucture, that forms the slow path in a fast IP route lookup implementation. Author: Chaitanya Kodeboyina (chaitk) 26-Nov-1997 Revision History: --*/ #include "precomp.h" #include "strie.h" UINT CALLCONV InitSTrie(IN STrie * pSTrie, IN ULONG maxMemory) /*++ Routine Description: Initializes an S-trie. This should be done prior to any other trie operations. Arguments: pSTrie - Pointer to the trie to be initialized maxMemory - Limit on memory taken by the S-Trie Return Value: TRIE_SUCCESS --*/ { // Zero all the memory for the trie header RtlZeroMemory(pSTrie, sizeof(STrie)); // Set a limit on the memory for trie/nodes pSTrie->availMemory = maxMemory; return TRIE_SUCCESS; } UINT CALLCONV InsertIntoSTrie(IN STrie * pSTrie, IN Route * pIncRoute, IN ULONG matchFlags, OUT Route ** ppInsRoute, OUT Dest ** ppOldBestDest, OUT Dest ** ppNewBestDest, OUT Route ** ppOldBestRoute ) /*++ Routine Description: Inserts a route corresponding to an address prefix into a S-trie, and fills in best dest for addresses that match this prefix both before and after insertion of route. Arguments: pSTrie - Pointer to trie to insert into pIncRoute - Pointer to the incoming route matchFlags - Flags to direct route matching ppInsRoute - Pointer to the route inserted ppOldBestDest - Best dest before insertion ppNewBestDest - Best dest after insertion ppOldBestRoute - Best route before insertion Return Value: TRIE_SUCCESS or ERROR_TRIE_* --*/ { STrieNode *pNewNode; STrieNode *pPrevNode; STrieNode *pCurrNode; STrieNode *pOthNode; Dest *pCurrDest; Dest *pNewDest; Dest *pBestDest; Route *pNewRoute; Route *pPrevRoute; Route *pCurrRoute; ULONG addrBits; ULONG tempBits; UINT numBits; UINT nextBits; UINT matchBits; UINT bitsLeft; UINT distPos; UINT nextChild; UINT i, j; #if DBG // Make sure the trie is initialized if (!pSTrie) { Fatal("Insert Route: STrie not initialized", ERROR_TRIE_NOT_INITED); } #endif // Make sure input route is valid if (NULL_ROUTE(pIncRoute)) { Error("Insert Route: NULL or invalid route", ERROR_TRIE_BAD_PARAM); } if (LEN(pIncRoute) > ADDRSIZE) { Error("Insert Route: Invalid mask length", ERROR_TRIE_BAD_PARAM); } // Use addr bits to index the trie addrBits = RtlConvertEndianLong(DEST(pIncRoute)); bitsLeft = LEN(pIncRoute); // Make sure addr and mask agree if (ShowMostSigNBits(addrBits, bitsLeft) != addrBits) { Error("Insert Route: Addr & mask don't agree", ERROR_TRIE_BAD_PARAM); } TRY_BLOCK { // Start going down the search trie // Initialize any new allocations pNewNode = NULL; pOthNode = NULL; pNewDest = NULL; pNewRoute = NULL; // Initialize other loop variables pBestDest = NULL; nextChild = 0; pPrevNode = STRUCT_OF(STrieNode, &pSTrie->trieRoot, child[0]); do { // Start this loop by advancing to the next child pCurrNode = pPrevNode->child[nextChild]; if (pCurrNode == NULL) { // Case 1: Found a NULL - insert now // Make a copy of the incoming route NewRouteInSTrie(pSTrie, pNewRoute, pIncRoute); // Allocate a dest with the new route NewDestInSTrie(pSTrie, pNewRoute, pNewDest); // New node with bits left unmatched NewSTrieNode(pSTrie, pNewNode, bitsLeft, addrBits, pNewDest); // Stick it as the correct child of node pPrevNode->child[nextChild] = pNewNode; break; } // Number of bits to match in this trie node nextBits = pCurrNode->numBits; matchBits = (nextBits > bitsLeft) ? bitsLeft : nextBits; // Adjust next node bits for dist posn check // Get distinguishing postion for bit patterns distPos = PickDistPosition(pCurrNode->keyBits, addrBits, matchBits, tempBits); if (distPos == nextBits) { // Completely matches next node if (distPos == bitsLeft) { // We have exhausted all incoming bits if (!NULL_DEST(pCurrNode->dest)) { // Case 2: This trie node has a route // Insert in sorted order of metric pCurrDest = pCurrNode->dest; // Give a ptr to the old best route CopyRoutePtr(ppOldBestRoute, pCurrDest->firstRoute); pPrevRoute = NULL; pCurrRoute = pCurrDest->firstRoute; // Search for an adequate match (IF, NHop) do { // Use the flags to control matching if ((((matchFlags & MATCH_INTF) == 0) || (IF(pCurrRoute) == IF(pIncRoute))) && (((matchFlags & MATCH_NHOP) == 0) || (NHOP(pCurrRoute) == NHOP(pIncRoute)))) break; pPrevRoute = pCurrRoute; pCurrRoute = NEXT(pPrevRoute); } while (!NULL_ROUTE(pCurrRoute)); if (NULL_ROUTE(pCurrRoute)) { // Case 2.1: No matching route // Create a new copy of route NewRouteInSTrie(pSTrie, pNewRoute, pIncRoute); } else { // Case 2.2: A Matching Route // Has the metric changed ? if (METRIC(pCurrRoute) != METRIC(pIncRoute)) { // Remove route from current position if (!NULL_ROUTE(pPrevRoute)) { // Remove it from middle of list NEXT(pPrevRoute) = NEXT(pCurrRoute); } else { // Remove from beginning of list pCurrDest->firstRoute = NEXT(pCurrRoute); } } // Keep the new/updated route for later pNewRoute = pCurrRoute; } if (NULL_ROUTE(pCurrRoute) || (METRIC(pCurrRoute) != METRIC(pIncRoute))) { // Update metric for new / changing route METRIC(pNewRoute) = METRIC(pIncRoute); // Traverse list looking for new position pPrevRoute = NULL; pCurrRoute = pCurrDest->firstRoute; while (!NULL_ROUTE(pCurrRoute)) { if (METRIC(pCurrRoute) > METRIC(pIncRoute)) break; pPrevRoute = pCurrRoute; pCurrRoute = NEXT(pPrevRoute); } // Insert at the new proper position NEXT(pNewRoute) = pCurrRoute; if (!NULL_ROUTE(pPrevRoute)) { // Insert in the middle of list NEXT(pPrevRoute) = pNewRoute; } else { // Insert at beginning of list pCurrDest->firstRoute = pNewRoute; } } // Give a ptr to newly inserted route CopyRoutePtr(ppInsRoute, pNewRoute); // Give a ptr to the old best dest CopyDestPtr(ppOldBestDest, pCurrDest); // Give a ptr to the new best dest CopyDestPtr(ppNewBestDest, pCurrDest); // Update the best routes cache on node CacheBestRoutesInDest(pCurrDest); return TRIE_SUCCESS; } else { // Case 3: This node was a marker // Create a new route & attach it // Create a new copy of this route NewRouteInSTrie(pSTrie, pNewRoute, pIncRoute); // Allocate a dest with the new route NewDestInSTrie(pSTrie, pNewRoute, pNewDest); // And attach dest to the marker node pCurrNode->dest = pNewDest; } break; } else { // Case 4: We still have bits left here // Go down for more specific match // Update node with best dest so far if (!NULL_DEST(pCurrNode->dest)) { pBestDest = pCurrNode->dest; } // Discard used bits for this iteration addrBits <<= matchBits; bitsLeft -= matchBits; // Prepare node for the next iteration pPrevNode = pCurrNode; // Bit 1 gives direction to search next nextChild = PickMostSigNBits(addrBits, 1); } } else { if (distPos == bitsLeft) { // Case 5: The route falls on this branch // Insert a new node in the same branch // Make a copy of the new route NewRouteInSTrie(pSTrie, pNewRoute, pIncRoute); // Allocate a dest with the new route NewDestInSTrie(pSTrie, pNewRoute, pNewDest); // New node with bits left unmatched NewSTrieNode(pSTrie, pNewNode, distPos, ShowMostSigNBits(addrBits, distPos), pNewDest); pPrevNode->child[nextChild] = pNewNode; // Adjust the next node - numbits etc pCurrNode->keyBits <<= distPos, pCurrNode->numBits -= distPos; // Stick next node in the correct child nextChild = PickMostSigNBits(pCurrNode->keyBits, 1); pNewNode->child[nextChild] = pCurrNode; break; } else { // Case 6: The route fragments the path // Create a new branch with two nodes // First make a copy of the new route NewRouteInSTrie(pSTrie, pNewRoute, pIncRoute); // Allocate a dest with the new route NewDestInSTrie(pSTrie, pNewRoute, pNewDest); // Branch node with non distinguishing bits NewSTrieNode(pSTrie, pOthNode, distPos, ShowMostSigNBits(addrBits, distPos), NULL); // A Leaf node with the distinguishing bits bitsLeft -= distPos; addrBits <<= distPos; NewSTrieNode(pSTrie, pNewNode, bitsLeft, addrBits, pNewDest); // Stick new branch node into the trie pPrevNode->child[nextChild] = pOthNode; // Set the children of the branch node // Adjust the next node - numbits etc pCurrNode->keyBits <<= distPos, pCurrNode->numBits -= distPos; // Stick next node in the correct child nextChild = PickMostSigNBits(pCurrNode->keyBits, 1); pOthNode->child[nextChild] = pCurrNode; // Stick new leaf node as the other child pOthNode->child[1 - nextChild] = pNewNode; break; } } } while (TRUE); // Give a ptr to the inserted route CopyRoutePtr(ppInsRoute, pNewRoute); // Give a ptr to the old best dest CopyDestPtr(ppOldBestDest, pBestDest); // Give a ptr to the old best route if (!NULL_DEST(pBestDest)) { CopyRoutePtr(ppOldBestRoute, pBestDest->firstRoute); } // Give a ptr to the new best dest CopyDestPtr(ppNewBestDest, pNewDest); // Route is the only route on dest if (pNewDest->maxBestRoutes > 0) { pNewDest->numBestRoutes = 1; pNewDest->bestRoutes[0] = pNewRoute; } return TRIE_SUCCESS; } ERR_BLOCK { // Not enough RESOURCES to add a new route // Free the memory for the new route alloc if (pNewRoute) { FreeRouteInSTrie(pSTrie, pNewRoute); } // Free memory for the dest on the new node if (pNewDest) { FreeDestInSTrie(pSTrie, pNewDest); } // Free the memory for the new tnode alloc if (pNewNode) { FreeSTrieNode(pSTrie, pNewNode); } // Free memory for any other new tnode alloc if (pOthNode) { FreeSTrieNode(pSTrie, pOthNode); } } END_BLOCK } UINT CALLCONV DeleteFromSTrie(IN STrie * pSTrie, IN Route * pIncRoute, IN ULONG matchFlags, OUT Route ** ppDelRoute, OUT Dest ** ppOldBestDest, OUT Dest ** ppNewBestDest, OUT Route ** ppOldBestRoute ) /*++ Routine Description: Deletes a route corresponding to an address prefix into a S-trie, and fills in best dest for addresses that match this prefix both before and after deletion of route. Arguments: pSTrie - Pointer to trie to delete from pIncRoute - Pointer to the incoming route matchFlags - Flags to direct route matching ppDelRoute - Pointer to the route deleted ppOldBestDest - Best dest before deletion ppNewBestDest - Best dest after deletion ppOldBestRoute - Best route before deletion Return Value: TRIE_SUCCESS or ERROR_TRIE_* --*/ { STrieNode *pPrevNode; STrieNode *pCurrNode; STrieNode *pNextNode; STrieNode *pOtherNode; Dest *pBestDest; Dest *pCurrDest; Route *pPrevRoute; Route *pCurrRoute; ULONG addrBits; ULONG tempBits; UINT numBits; UINT nextBits; UINT matchBits; UINT bitsLeft; UINT distPos; UINT nextChild; UINT i, j; #if DBG if (!pSTrie) { Fatal("Delete Route: STrie not initialized", ERROR_TRIE_NOT_INITED); } #endif // Make sure input route is valid if (NULL_ROUTE(pIncRoute)) { Error("Delete Route: NULL or invalid route", ERROR_TRIE_BAD_PARAM); } if (LEN(pIncRoute) > ADDRSIZE) { Error("Delete Route: Invalid mask length", ERROR_TRIE_BAD_PARAM); } // Use addr bits to index the trie addrBits = RtlConvertEndianLong(DEST(pIncRoute)); bitsLeft = LEN(pIncRoute); // Make sure addr and mask agree if (ShowMostSigNBits(addrBits, bitsLeft) != addrBits) { Error("Delete Route: Addr & mask don't agree", ERROR_TRIE_BAD_PARAM); } // Start going down the search trie pBestDest = NULL; nextChild = 0; pPrevNode = STRUCT_OF(STrieNode, &pSTrie->trieRoot, child[0]); do { // Start this loop by advancing to the next child pCurrNode = pPrevNode->child[nextChild]; if (pCurrNode == NULL) { // Case 1: Found a NULL, end search // Route not found, return an error Error("Delete Route #0: Route not found", ERROR_TRIE_NO_ROUTES); } // Number of bits to match in this trie node nextBits = pCurrNode->numBits; matchBits = (nextBits > bitsLeft) ? bitsLeft : nextBits; // Adjust next node bits for dist posn check // Get distinguishing postion for bit patterns distPos = PickDistPosition(pCurrNode->keyBits, addrBits, matchBits, tempBits); if (distPos == nextBits) { // Completely matches next node if (distPos == bitsLeft) { // We have exhausted all incoming bits // End search, see if we found a route if (!NULL_DEST(pCurrNode->dest)) { pCurrDest = pCurrNode->dest; // This node starts a valid route list // Give a ptr to the old best dest CopyDestPtr(ppOldBestDest, pCurrDest); // Give a ptr to the old best route CopyRoutePtr(ppOldBestRoute, pCurrDest->firstRoute); // Give a ptr to the new best dest CopyDestPtr(ppNewBestDest, pCurrDest); // Match the rest by walking the list // sorted increasing order of metric pPrevRoute = NULL; pCurrRoute = pCurrDest->firstRoute; do { // Use the flags to control matching // N.B. Note that certain clients are not allowed // to delete local routes. if ((((matchFlags & MATCH_INTF) == 0) || (IF(pCurrRoute) == IF(pIncRoute))) && (((matchFlags & MATCH_NHOP) == 0) || (NHOP(pCurrRoute) == NHOP(pIncRoute))) && (((matchFlags & MATCH_EXCLUDE_LOCAL) == 0) || (PROTO(pCurrRoute) != IRE_PROTO_LOCAL))) { // Case 2: Found an adequate match //* Do the actual deletion here * if (!NULL_ROUTE(pPrevRoute)) { // Delete from middle of the list NEXT(pPrevRoute) = NEXT(pCurrRoute); } else { // Delete from beginning of list pCurrDest->firstRoute = NEXT(pCurrRoute); } break; } pPrevRoute = pCurrRoute; pCurrRoute = NEXT(pPrevRoute); } while (!NULL_ROUTE(pCurrRoute)); if (NULL_ROUTE(pCurrRoute)) { // Route not found, return an error Error("Delete Route #1: Route not found", ERROR_TRIE_NO_ROUTES); } // Give a ptr to newly deleted route CopyRoutePtr(ppDelRoute, pCurrRoute); // Did the list become empty after deletion ? if (NULL_ROUTE(pCurrDest->firstRoute)) { // List is empty, so garbage collection // Give a ptr to the new best dest CopyDestPtr(ppNewBestDest, pBestDest); // Free destination as all routes gone FreeDestInSTrie(pSTrie, pCurrNode->dest); if (pCurrNode->child[0] && pCurrNode->child[1]) { // Case 3: Both children are non NULL // Just remove route from the node // Route already removed from node } else if (pCurrNode->child[0] || pCurrNode->child[1]) { // Case 4: One of the children is not NULL // Pull up lonely child in place of node // Pick the correct child to pull up if (pCurrNode->child[0]) pNextNode = pCurrNode->child[0]; else pNextNode = pCurrNode->child[1]; // Child node bears bits of deleted node pNextNode->keyBits >>= pCurrNode->numBits; pNextNode->keyBits |= pCurrNode->keyBits; pNextNode->numBits += pCurrNode->numBits; pPrevNode->child[nextChild] = pNextNode; // Destroy trie node marked for deletion FreeSTrieNode(pSTrie, pCurrNode); } else { // Node to be deleted has no children if (&pPrevNode->child[nextChild] == &pSTrie->trieRoot) { // Case 5: Root node is being deleted // Detach node from trie root & delete // Just detach by removing the pointer pPrevNode->child[nextChild] = NULL; // Destroy trie node marked for deletion FreeSTrieNode(pSTrie, pCurrNode); } else { if (!NULL_DEST(pPrevNode->dest)) { // Case 6: Parent has a route on it // Detach child from parent & delete // Just detach by removing the pointer pPrevNode->child[nextChild] = NULL; // Destroy trie node marked for deletion FreeSTrieNode(pSTrie, pCurrNode); } else { // Case 7: Parent has no route on it // Pull up other child of parent node pOtherNode = pPrevNode->child[1 - nextChild]; // Make sure no 1-way branching Assert(pOtherNode != NULL); // Parent node bears bits of sibling node pPrevNode->keyBits |= (pOtherNode->keyBits >> pPrevNode->numBits); pPrevNode->numBits += pOtherNode->numBits; // Move the route up too - move content pPrevNode->dest = pOtherNode->dest; pPrevNode->child[0] = pOtherNode->child[0]; pPrevNode->child[1] = pOtherNode->child[1]; FreeSTrieNode(pSTrie, pCurrNode); FreeSTrieNode(pSTrie, pOtherNode); } } } } else { // We still have some routes on the dest // Update the best routes cache on node CacheBestRoutesInDest(pCurrDest); } // Consider route as deleted at this point // FreeRouteInSTrie(pSTrie, pCurrRoute); break; } else { // Case 7: This node was a marker // No Route to delete in this node Error("Delete Route #2: Route not found", ERROR_TRIE_NO_ROUTES); } } else { // Case 8: We still have bits left here // Go down for more specific match // Update best value of route so far if (!NULL_DEST(pCurrNode->dest)) { pBestDest = pCurrNode->dest; } // Discard used bits for this iteration addrBits <<= matchBits; bitsLeft -= matchBits; // Prepare node for the next iteration pPrevNode = pCurrNode; // Bit 1 gives direction to search next nextChild = PickMostSigNBits(addrBits, 1); } } else { // Case 9: Did not match the next node // Route not found, fill next best Error("Delete Route #3: Route not found", ERROR_TRIE_NO_ROUTES); } } while (TRUE); return TRIE_SUCCESS; } UINT CALLCONV SearchRouteInSTrie(IN STrie * pSTrie, IN ULONG routeDest, IN ULONG routeMask, IN ULONG routeNHop, IN PVOID routeOutIF, IN ULONG matchFlags, OUT Route ** ppOutRoute) /*++ Routine Description: Search for a specific route in an S-trie Arguments: pSTrie - Pointer to the S-trie to search routeDest - Dest of route being looked up routeMask - Mask of route being looked up routeNHop - NHop of route being looked up routeOutIF - Outgoing IF for this route matchFlags - Flags to direct route matching ppOutRoute - To return the best route match Return Value: TRIE_SUCCESS or ERROR_TRIE_* --*/ { STrieNode *pPrevNode; STrieNode *pCurrNode; STrieNode *pNextNode; STrieNode *pOtherNode; Dest *pCurrDest; Dest *pBestDest; Route *pPrevRoute; Route *pCurrRoute; ULONG addrBits; ULONG tempBits; UINT numBits; UINT nextBits; UINT matchBits; UINT bitsLeft; UINT distPos; UINT nextChild; UINT bestMetric; UINT i, j; #if DBG if (!pSTrie) { Fatal("Search Route: STrie not initialized", ERROR_TRIE_NOT_INITED); } #endif *ppOutRoute = NULL; // Use addr bits to index the trie addrBits = RtlConvertEndianLong(routeDest); //* Assume an contiguous IP mask * tempBits = RtlConvertEndianLong(routeMask); bitsLeft = 0; while (tempBits != 0) { bitsLeft++; tempBits <<= 1; } // Make sure addr and mask agree if (ShowMostSigNBits(addrBits, bitsLeft) != addrBits) { Error("Search Route: Addr & mask don't agree", ERROR_TRIE_BAD_PARAM); } // Start going down the search trie pBestDest = NULL; nextChild = 0; pPrevNode = STRUCT_OF(STrieNode, &pSTrie->trieRoot, child[0]); do { // Start this loop by advancing to the next child pCurrNode = pPrevNode->child[nextChild]; if (pCurrNode == NULL) { // Case 1: Found a NULL, end search // Route not found, fill next best // Give a copy of the next best route if (!NULL_DEST(pBestDest)) { CopyRoutePtr(ppOutRoute, pBestDest->firstRoute); } Error("Search Route #0: Route not found", ERROR_TRIE_NO_ROUTES); } // Number of bits to match in this trie node nextBits = pCurrNode->numBits; matchBits = (nextBits > bitsLeft) ? bitsLeft : nextBits; // Adjust next node bits for dist posn check // Get distinguishing postion for bit patterns distPos = PickDistPosition(pCurrNode->keyBits, addrBits, matchBits, tempBits); if (distPos == nextBits) { // Completely matches next node if (distPos == bitsLeft) { // We have exhausted all incoming bits // End search, see if we found a route if (!NULL_DEST(pCurrNode->dest)) { // This node starts a valid route list pCurrDest = pCurrNode->dest; // Match the rest by walking the list // sorted increasing order of metric pPrevRoute = NULL; pCurrRoute = pCurrDest->firstRoute; do { // Use the flags to control matching if ((((matchFlags & MATCH_INTF) == 0) || (IF(pCurrRoute) == routeOutIF)) && (((matchFlags & MATCH_NHOP) == 0) || (NHOP(pCurrRoute) == routeNHop))) { // Found adequately matched route // Just copy the route and return CopyRoutePtr(ppOutRoute, pCurrRoute); return TRIE_SUCCESS; } pPrevRoute = pCurrRoute; pCurrRoute = NEXT(pPrevRoute); } while (!NULL_ROUTE(pCurrRoute)); // Give a copy of the old route, or best route // for that prefix in case of no exact match if (NULL_ROUTE(pCurrRoute)) { CopyRoutePtr(ppOutRoute, pCurrDest->firstRoute); Error("Search Route #1: Route not found", ERROR_TRIE_NO_ROUTES); } break; } else { // Case 7: This node was a marker // No Route present in this node // Give a copy of the next best route if (!NULL_DEST(pBestDest)) { CopyRoutePtr(ppOutRoute, pBestDest->firstRoute); } Error("Search Route #2: Route not found", ERROR_TRIE_NO_ROUTES); } } else { // Case 8: We still have bits left here // Go down for more specific match // Update node with best dest so far if (!NULL_DEST(pCurrNode->dest)) { pBestDest = pCurrNode->dest; } // Discard used bits for this iteration addrBits <<= matchBits; bitsLeft -= matchBits; // Prepare node for the next iteration pPrevNode = pCurrNode; // Bit 1 gives direction to search next nextChild = PickMostSigNBits(addrBits, 1); } } else { // Case 9: Did not match the next node // Route not found, fill the next best // Give a copy of the next best route if (!NULL_DEST(pBestDest)) { CopyRoutePtr(ppOutRoute, pBestDest->firstRoute); } Error("Search Route #3: Route not found", ERROR_TRIE_NO_ROUTES); } } while (TRUE); return TRIE_SUCCESS; } Dest * CALLCONV SearchAddrInSTrie(IN STrie * pSTrie, IN ULONG Addr) /*++ Routine Description: Search for an address in an S-trie Arguments: pSTrie - Pointer to the trie to search Addr - Pointer to addr being queried Return Value: Return best route match for this address --*/ { STrieNode *pCurrNode; Dest *pBestDest; UINT nextChild; ULONG addrBits; ULONG keyMask; ULONG keyBits; #if DBG if (!pSTrie) { Fatal("Search Addr: STrie not initialized", ERROR_TRIE_NOT_INITED); } #endif addrBits = RtlConvertEndianLong(Addr); // Start going down the search trie pBestDest = NULL; nextChild = 0; pCurrNode = STRUCT_OF(STrieNode, &pSTrie->trieRoot, child[0]); do { // Start this loop by advancing to next child pCurrNode = pCurrNode->child[nextChild]; if (pCurrNode == NULL) { // Case 1: Found a NULL, end search break; } // Mask of bits to use in this trie node keyMask = MaskBits(pCurrNode->numBits); // Value of non-masked bits to match now keyBits = pCurrNode->keyBits; // Try to match the bits with above mask if ((addrBits & keyMask) != keyBits) { // Case 2: Failed to match this node break; } // Update best value of route so far if (!NULL_DEST(pCurrNode->dest)) { pBestDest = pCurrNode->dest; } // Go down for more specific match addrBits <<= pCurrNode->numBits; // Bit 1 gives direction to search next nextChild = PickMostSigNBits(addrBits, 1); } while (TRUE); return pBestDest; } UINT CALLCONV IterateOverSTrie(IN STrie * pSTrie, IN STrieCtxt * pCtxt, OUT Route ** ppRoute, OUT Dest** ppDest) /*++ Routine Description: Get the next route in the S-Trie Arguments: pSTrie - Pointer to trie to iterate over pCtxt - Pointer to iterator context ppRoute - To return the next S-trie route ppDest - To return destinations instead of routes Return Value: TRIE_SUCCESS or ERROR_TRIE_* --*/ { STrieNode *nodeInLevel[MAXLEVEL + 1]; STrieNode *pPrevNode; STrieNode *pCurrNode; STrieNode *pNextNode; STrieNode *pOtherNode; Route *pPrevRoute; Route *pCurrRoute; ULONG addrBits; ULONG tempBits; UINT numLevels; UINT numBits; UINT nextBits; UINT matchBits; UINT bitsLeft; UINT distPos; UINT nextChild; UINT i, j; BOOLEAN routeToReturn; Dest *pCurrDest; #if DBG if (!pSTrie) { Fatal("Iterate Over STrie: STrie not initialized", ERROR_TRIE_NOT_INITED); } #endif // Check if the context is a valid one if (NULL_ROUTE(pCtxt->pCRoute)) { // NULL Context Case -- First Time // Do we have any routes at all ? if (pSTrie->trieRoot == NULL) { return ERROR_TRIE_NO_ROUTES; } // Start from the very beginning // Fill in actual context pCtxt->currAddr = 0; pCtxt->currALen = 0; pCurrDest = pSTrie->trieRoot->dest; pCtxt->pCRoute = pCurrDest ? pCurrDest->firstRoute : NULL; // Fill generated context numLevels = 1; nodeInLevel[0] = pSTrie->trieRoot; } else { // Non NULL Context -- Generate path // of current route from trie's root // Use addr bits to index the trie addrBits = RtlConvertEndianLong(pCtxt->currAddr); bitsLeft = pCtxt->currALen; #if DBG // Make sure addr and mask agree if (ShowMostSigNBits(addrBits, bitsLeft) != addrBits) { Fatal("Search Route: Addr & mask don't agree", ERROR_TRIE_BAD_PARAM); } #endif // Start going down the search trie numLevels = 0; nextChild = 0; pPrevNode = STRUCT_OF(STrieNode, &pSTrie->trieRoot, child[0]); do { // Start this loop by advancing to the next child pCurrNode = pPrevNode->child[nextChild]; // Push pointer to this trie node into the stack nodeInLevel[numLevels++] = pCurrNode; // Valid context always matches all nodes exactly Assert(pCurrNode != NULL); // Get Number of bits to match in this trie node nextBits = pCurrNode->numBits; matchBits = (nextBits > bitsLeft) ? bitsLeft : nextBits; // Adjust next node bits for dist posn check // Get distinguishing postion for bit patterns distPos = PickDistPosition(pCurrNode->keyBits, addrBits, matchBits, tempBits); // Valid context always matches all nodes exactly Assert(distPos == nextBits); if (distPos == bitsLeft) { // We have exhausted all incoming bits // We should have found a route (list) pCurrDest = pCurrNode->dest; #if DBG // This node starts a valid route list Assert(pCurrDest); // Try matching the route in context pCurrRoute = pCurrDest->firstRoute; do { if (pCurrRoute == pCtxt->pCRoute) { break; } pCurrRoute = NEXT(pCurrRoute); } while (!NULL_ROUTE(pCurrRoute)); // We should find a definite match Assert(!NULL_ROUTE(pCurrRoute)); #endif // DBG // We have the full path from root to // current node in the stack of nodes break; } // We still have key bits left here // Go down for more specific match // Discard used bits for this iteration addrBits <<= matchBits; bitsLeft -= matchBits; // Prepare node for the next iteration pPrevNode = pCurrNode; // Bit 1 gives direction to search next nextChild = PickMostSigNBits(addrBits, 1); } while (TRUE); } // We have no routes to return at this point routeToReturn = FALSE; // Set direction to print route in context nextChild = LCHILD; do { // Get pointer to the current node & direction pCurrNode = nodeInLevel[numLevels - 1]; // Return route its first time on top of stack if (nextChild == LCHILD) { pCurrRoute = pCtxt->pCRoute; if (!NULL_ROUTE(pCurrRoute)) { // We have a valid route to return routeToReturn = TRUE; if (ppDest) { CopyDestPtr(ppDest, pCurrDest); } else { CopyRoutePtr(ppRoute, pCurrRoute); // Got a valid next route - return pCtxt->pCRoute = NEXT(pCurrRoute); if (!NULL_ROUTE(NEXT(pCurrRoute))) { // Update the context and return pCtxt->currAddr = DEST(pCtxt->pCRoute); pCtxt->currALen = LEN(pCtxt->pCRoute); return ERROR_TRIE_NOT_EMPTY; } } // Search for the valid next route } } // Update the context to reflect an access switch (nextChild) { case LCHILD: // Push left child if not NULL pNextNode = pCurrNode->child[0]; if (pNextNode != NULL) { // Push next level on the stack - Go Left nodeInLevel[numLevels++] = pNextNode; nextChild = LCHILD; pCtxt->pCRoute = pNextNode->dest ? pNextNode->dest->firstRoute : NULL; // Return if we have a route to send back // & we also have located the next route if ((routeToReturn) && !NULL_DEST(pNextNode->dest)) { // Update the context and return pCtxt->currAddr = DEST(pCtxt->pCRoute); pCtxt->currALen = LEN(pCtxt->pCRoute); return ERROR_TRIE_NOT_EMPTY; } continue; } case RCHILD: // Push right child if not NULL pNextNode = pCurrNode->child[1]; if (pNextNode != NULL) { // Push next level on the stack - Go Left nodeInLevel[numLevels++] = pNextNode; nextChild = LCHILD; pCtxt->pCRoute = pNextNode->dest ? pNextNode->dest->firstRoute : NULL; // Return if we have a route to send back // & we also have located the next route if ((routeToReturn) && !NULL_DEST(pNextNode->dest)) { // Update the context and return pCtxt->currAddr = DEST(pCtxt->pCRoute); pCtxt->currALen = LEN(pCtxt->pCRoute); return ERROR_TRIE_NOT_EMPTY; } continue; } case PARENT: // Pop node & calculate new direction // Are we done iterating ? if (--numLevels == 0) { return TRIE_SUCCESS; } pPrevNode = nodeInLevel[numLevels - 1]; if (pPrevNode->child[0] == pCurrNode) { nextChild = RCHILD; } else { nextChild = PARENT; } continue; } } while (TRUE); } UINT CALLCONV IsSTrieIteratorValid(IN STrie * pSTrie, IN STrieCtxt * pCtxt) /*++ Routine Description: Make sure that iterator's context is valid Arguments: pSTrie - Pointer to trie to iterate over pCtxt - Pointer to iterator context Return Value: TRIE_SUCCESS or ERROR_TRIE_* --*/ { Route *pCurrRoute; ULONG addrMask; ULONG maskBits; if (NULL_ROUTE(pCtxt->pCRoute)) { // NULL Context Case if (pSTrie->trieRoot != NULL) { return TRIE_SUCCESS; } return ERROR_TRIE_NO_ROUTES; } else { // Non NULL Context // Make sure current route is valid // Search for a node with dest, len // Generate mask from address length maskBits = MaskBits(pCtxt->currALen); // Convert endian - search needs it addrMask = RtlConvertEndianLong(maskBits); if (SearchRouteInSTrie(pSTrie, pCtxt->currAddr, addrMask, 0, NULL, MATCH_NONE, &pCurrRoute) != TRIE_SUCCESS) { return ERROR_TRIE_BAD_PARAM; } // Search for the route in context while (!NULL_ROUTE(pCurrRoute)) { if (pCurrRoute == pCtxt->pCRoute) { return TRIE_SUCCESS; } pCurrRoute = NEXT(pCurrRoute); } return ERROR_TRIE_BAD_PARAM; } } UINT CALLCONV CleanupSTrie(IN STrie * pSTrie) /*++ Routine Description: Deletes an S-trie if it is empty Arguments: ppSTrie - Ptr to the S-trie Return Value: TRIE_SUCCESS or ERROR_TRIE_* --*/ { // Zero the memory for the trie header RtlZeroMemory(pSTrie, sizeof(STrie)); return TRIE_SUCCESS; } VOID CALLCONV CacheBestRoutesInDest(IN Dest * pDest) /*++ Routine Description: Updates a destination's best-routes cache Arguments: pDest - Ptr to the destination Return Value: none. --*/ { Route* pCurrRoute; UINT bestMetric, i; if (!(pCurrRoute = pDest->firstRoute)) { return; } // Get metric of the current best route, and store as many routes with the // same metric as possible bestMetric = METRIC(pCurrRoute); for (i = 0; i < pDest->maxBestRoutes; i++) { if (NULL_ROUTE(pCurrRoute) || (METRIC(pCurrRoute) != bestMetric)) { break; } pDest->bestRoutes[i] = pCurrRoute; pCurrRoute = NEXT(pCurrRoute); } pDest->numBestRoutes = (USHORT) i; } #if DBG VOID CALLCONV PrintSTrie(IN STrie * pSTrie, IN UINT printFlags) /*++ Routine Description: Print an S-Trie Arguments: pSTrie - Pointer to the S-Trie printFlags - Information to print Return Value: None --*/ { if (pSTrie == NULL) { Print("%s", "Uninitialized STrie\n\n"); return; } if ((printFlags & SUMM) == SUMM) { Print("\n\n/***Slow-Trie------------------------------------------------"); Print("\n/***---------------------------------------------------------\n"); } if (printFlags & POOL) { Print("Available Memory: %10lu\n\n", pSTrie->availMemory); } if (printFlags & STAT) { Print("Statistics:\n\n"); Print("Total Number of Nodes : %d\n", pSTrie->numNodes); Print("Total Number of Routes: %d\n", pSTrie->numRoutes); Print("Total Number of Dests : %d\n", pSTrie->numDests); } if (printFlags & TRIE) { if (pSTrie->trieRoot == NULL) { Print("\nEmpty STrie\n"); } else { PrintSTrieNode(pSTrie->trieRoot); } } if ((printFlags & SUMM) == SUMM) { Print("\n---------------------------------------------------------***/\n"); Print("---------------------------------------------------------***/\n\n"); } } VOID CALLCONV PrintSTrieNode(IN STrieNode * pSTrieNode) /*++ Routine Description: Print an S-trie node Arguments: pSTrieNode - Pointer to the S-trie node Return Value: None --*/ { if (pSTrieNode == NULL) { return; } Print("\n--------------------------------------------------------\n"); Print("Child @ %08x", pSTrieNode); Print("\n--------------------------------------------------------\n"); Print("Key: Num of Bits : %8d, Value of Bits: %08x\n", pSTrieNode->numBits, pSTrieNode->keyBits); if (NULL_DEST(pSTrieNode->dest)) { Print("NULL Dest\n"); } else { PrintDest(pSTrieNode->dest); } Print("Children: On the left %08x, On the right %08x\n", pSTrieNode->child[0], pSTrieNode->child[1]); Print("\n--------------------------------------------------------\n"); Print("\n\n"); PrintSTrieNode(pSTrieNode->child[0]); PrintSTrieNode(pSTrieNode->child[1]); } #endif // DBG