/*++ Copyright (c) 1997 - 98, Microsoft Corporation Module Name: rtm1to2.c Abstract: Contains routines that wrap RTMv2 functions in the RTMv1 API. Author: Chaitanya Kodeboyina (chaitk) 13-Oct-1998 Revision History: --*/ #include "pchrtm.h" #pragma hdrstop #if WRAPPER #include "rtm1to2.h" // Wrapper Globals V1_GLOBAL_INFO V1Globals; DWORD RtmCreateRouteTable ( IN DWORD ProtocolFamily, IN PRTM_PROTOCOL_FAMILY_CONFIG Config ) /*++ Routine Description: Triggers the creation of a new route table corresponding to a protocol family (same as address family in RTMv2) in the default instance of RTMv2 by performing the very first registration in that protocol family. This default registration is also used for mapping RTMv1 operations that do not require a registration handle (V1 enums etc.) to their corresponding RTMv2 operations. Note that all RTMv2 calls require a registration handle. This call also creates a list of all V1 registrations at any time. This is used to automatically deregister all RTMv1 registrations before destroying this route table. We also set up the notification of changes in best routes to the router manager (RM) that invoked this function. Arguments: ProtocolFamily - Protocol Family (same as v2 address family) Config - Protocol family's router manager callbacks (Only the "route change callback" and the "validate route callback" funcs are used) Return Value: Status of the operation --*/ { HANDLE V1RegHandle; DWORD Status; // // Validate incoming parameters before action // if (ProtocolFamily >= RTM_NUM_OF_PROTOCOL_FAMILIES) { return ERROR_INVALID_PARAMETER; } if (V1Globals.PfRegInfo[ProtocolFamily]) { return ERROR_ALREADY_EXISTS; } // // Initialize the lock that guards regns list // try { InitializeCriticalSection(&V1Globals.PfRegnsLock[ProtocolFamily]); } except(EXCEPTION_EXECUTE_HANDLER) { return ERROR_NOT_ENOUGH_MEMORY; } // Initialize list of regns on protocol family InitializeListHead(&V1Globals.PfRegistrations[ProtocolFamily]); // // Register on behalf of this protocol family // // This handle is also used for ops that // need a handle in RTM v2 but not in v1 // // We are also setting up best route change // notifications for RM using its callback // V1RegHandle = RtmpRegisterClient(ProtocolFamily, V1_WRAPPER_REGN_ID, Config->RPFC_Change, NULL, 0); if (V1RegHandle == NULL) { Status = GetLastError(); DeleteCriticalSection(&V1Globals.PfRegnsLock[ProtocolFamily]); return Status; } V1Globals.PfValidateRouteFunc[ProtocolFamily] = Config->RPFC_Validate; V1Globals.PfRegInfo[ProtocolFamily] = GET_POINTER_FROM_HANDLE(V1RegHandle); return NO_ERROR; } DWORD RtmDeleteRouteTable ( IN DWORD ProtocolFamily ) /*++ Routine Description: Deletes the route table for a particular address family after deregistering any active V1 registrations present. Note that atleast 1 registration (the wrapper's default registration) is active at this point. We assume that all RTMv2 protocols have deregistered by the time this function is called. We also assume that no RTMv1 protocols are trying to register or deregister while this function is executing, as we do not hold the lock that protects the list of registrations. Arguments: ProtocolFamily - Protocol Family whose table is deleted. Return Value: Status of the operation --*/ { PV1_REGN_INFO Regn; PLIST_ENTRY Regns; DWORD Status; // // Validate incoming parameters before action // if (ProtocolFamily >= RTM_NUM_OF_PROTOCOL_FAMILIES) { return ERROR_INVALID_PARAMETER; } if (V1Globals.PfRegInfo[ProtocolFamily] == NULL) { return ERROR_INVALID_PARAMETER; } // // Deregister existing regns on protocol family // including the default regn of the V1 wrapper // Regns = &V1Globals.PfRegistrations[ProtocolFamily]; // We have atleast the default regn available ASSERT(!IsListEmpty(Regns)); while (!IsListEmpty(Regns)) { Regn = CONTAINING_RECORD(Regns->Flink, V1_REGN_INFO, RegistrationsLE); Status = RtmDeregisterClient(MAKE_HANDLE_FROM_POINTER(Regn)); ASSERT(Status == NO_ERROR); } // Free the lock used to guard the regns list DeleteCriticalSection(&V1Globals.PfRegnsLock[ProtocolFamily]); V1Globals.PfRegInfo[ProtocolFamily] = NULL; return NO_ERROR; } HANDLE WINAPI RtmRegisterClient ( IN DWORD ProtocolFamily, IN DWORD RoutingProtocol, IN HANDLE ChangeEvent OPTIONAL, IN DWORD Flags ) /*++ Routine Description: Registers an RTMv1 client with the default instance and given protocol family in RTMv2. Also sets up notification of best route changes if caller asks for it. Arguments: ProtocolFamily - Protocol Family we are registering with. RoutingProtocol - Protocol ID of registering component. ChangeEvent - Event to indicate changes in best routes. Flags - RTM_PROTOCOL_SINGLE_ROUTE indicates that this protocol adds atmost one route per destination. Return Value: Registration Handle or NULL ( Use GetLastError() to get error ) --*/ { return RtmpRegisterClient(ProtocolFamily, RoutingProtocol, NULL, ChangeEvent, Flags); } HANDLE RtmpRegisterClient ( IN DWORD ProtocolFamily, IN DWORD RoutingProtocol, IN PROUTE_CHANGE_CALLBACK ChangeFunc OPTIONAL, IN HANDLE ChangeEvent OPTIONAL, IN DWORD Flags ) /*++ Routine Description: Registers an RTMv1 client with the default instance and given protocol family in RTMv2. Also sets up notification of best route changes if caller asks for it. Note that any protocol that needs to be indicated of best -route changes can either specify an event OR a callback for this purpose. Arguments: ProtocolFamily - Protocol Family we are registering with. RoutingProtocol - Protocol ID of registering component. ChangeFunc - Callback to indicates changes in best routes. ChangeEvent - Event to indicate changes in best routes. Flags - RTM_PROTOCOL_SINGLE_ROUTE indicates that this component keeps atmost one route per network (destination in RTMv2) in RTM. Return Value: Registration Handle or NULL ( Use GetLastError() to get error ) --*/ { PV1_REGN_INFO V1Regn; RTM_ENTITY_INFO EntityInfo; BOOL LockInited; BOOL Success; DWORD Status; // // Check parameters for validity (in v1 bounds) // if ((ProtocolFamily >= RTM_NUM_OF_PROTOCOL_FAMILIES) || (Flags & (~RTM_PROTOCOL_SINGLE_ROUTE))) { SetLastError(ERROR_INVALID_PARAMETER); return NULL; } // // Create a RTMv1->v2 registration wrapper // V1Regn = (PV1_REGN_INFO) AllocNZeroObject(sizeof(V1_REGN_INFO)); if (V1Regn == NULL) { SetLastError(ERROR_NOT_ENOUGH_MEMORY); return NULL; } LockInited = FALSE; do { #if DBG_HDL V1Regn->ObjectHeader.TypeSign = V1_REGN_ALLOC; #endif // // Register with RTMv2 after mapping input params to RTMv2 // // All v1 registrations fall in default Instance in RTMv2 EntityInfo.RtmInstanceId = 0; // We need to convert v1 protocol family id to winsock id EntityInfo.AddressFamily = ADDRESS_FAMILY[ProtocolFamily]; // All v1 protocols can register atmost once with RTMv2 // as they all will use the same "Protocol Instance Id" EntityInfo.EntityId.EntityProtocolId = RoutingProtocol; EntityInfo.EntityId.EntityInstanceId = V1_PROTOCOL_INSTANCE; Status = RtmRegisterEntity(&EntityInfo, (PRTM_ENTITY_EXPORT_METHODS) NULL, V2EventCallback, FALSE, &V1Regn->Rtmv2Profile, &V1Regn->Rtmv2RegHandle); if (Status != NO_ERROR) { break; } // // Cache RTMv1 specific params in RTMv1 regn // V1Regn->ProtocolFamily = ProtocolFamily; V1Regn->RoutingProtocol = RoutingProtocol; V1Regn->Flags = Flags; // // Store actual number of views in this regn // V1Regn->Rtmv2NumViews = V1Regn->Rtmv2Profile.NumberOfViews; // // Is caller interested in being notified of best route changes ? // if (/*ARGUMENT_PRESENT*/(ChangeFunc) || ARGUMENT_PRESENT(ChangeEvent)) { if (/*ARGUMENT_PRESENT*/(ChangeFunc)) { // The caller to be notified of changes directly V1Regn->NotificationFunc = ChangeFunc; } else { // Caller to be notified of changes with an event Success = ResetEvent(ChangeEvent); if (!Success) { Status = GetLastError(); break; } V1Regn->NotificationEvent = ChangeEvent; // Initialize lock to syncronize set/reset event try { InitializeCriticalSection(&V1Regn->NotificationLock); LockInited = TRUE; } except(EXCEPTION_EXECUTE_HANDLER) { Status = ERROR_NOT_ENOUGH_MEMORY; break; } } // // Register for change notifications with v2 // Status = RtmRegisterForChangeNotification(V1Regn->Rtmv2RegHandle, RTM_VIEW_MASK_UCAST, RTM_CHANGE_TYPE_ALL, (PVOID) V1Regn, &V1Regn->Rtmv2NotifyHandle); if (Status != NO_ERROR) { break; } } // // Stick it in the list of regns on protocol family // ACQUIRE_V1_REGNS_LOCK(ProtocolFamily); InsertHeadList(&V1Globals.PfRegistrations[ProtocolFamily], &V1Regn->RegistrationsLE); RELEASE_V1_REGNS_LOCK(ProtocolFamily); return MAKE_HANDLE_FROM_POINTER(V1Regn); } while (FALSE); // // Some error occured - clean up and return NULL // if (LockInited) { DeleteCriticalSection(&V1Regn->NotificationLock); } if (V1Regn->Rtmv2RegHandle) { ASSERT(RtmDeregisterEntity(V1Regn->Rtmv2RegHandle) == NO_ERROR); } #if DBG_HDL V1Regn->ObjectHeader.TypeSign = V1_REGN_FREED; #endif FreeObject(V1Regn); SetLastError(Status); return NULL; } DWORD WINAPI RtmDeregisterClient ( IN HANDLE ClientHandle ) /*++ Routine Description: Deregisters an RTMv1 client from the default instance and given protocol family in RTMv2. Also deletes any state that the RTMv1 caller left out - routes, nexthops etc. and deregisters any change notifications set up during registration time. Arguments: ClientHandle - RTMv1 registration handle being deregistered. Return Value: Status of the operation. --*/ { RTM_NEXTHOP_HANDLE EnumHandle; PV1_REGN_INFO V1Regn; HANDLE *Handles; UINT NumHandles, i; BOOL Success; DWORD Status; VALIDATE_V1_REGN_HANDLE(ClientHandle, &V1Regn); // // Remove the regn from the list of regns on protocol family // ACQUIRE_V1_REGNS_LOCK(V1Regn->ProtocolFamily); RemoveEntryList(&V1Regn->RegistrationsLE); RELEASE_V1_REGNS_LOCK(V1Regn->ProtocolFamily); do { // Allocate this var-size handles array on the stack Handles = ALLOC_HANDLES(V1Regn->Rtmv2Profile.MaxHandlesInEnum); // // Remove all the next-hops added by this client protocol // Status = RtmCreateNextHopEnum(V1Regn->Rtmv2RegHandle, 0, NULL, &EnumHandle); if (Status != NO_ERROR) { break; } do { NumHandles = V1Regn->Rtmv2Profile.MaxHandlesInEnum; Status = RtmGetEnumNextHops(V1Regn->Rtmv2RegHandle, EnumHandle, &NumHandles, Handles); for (i = 0; i < NumHandles; i++) { ASSERT(RtmDeleteNextHop(V1Regn->Rtmv2RegHandle, Handles[i], NULL) == NO_ERROR); } } while (Status == NO_ERROR); ASSERT(RtmDeleteEnumHandle(V1Regn->Rtmv2RegHandle, EnumHandle) == NO_ERROR); // // Clean up resources allocated for change processing // if (V1Regn->NotificationFunc || V1Regn->NotificationEvent) { // Stop the notification of changes to best routes Status = RtmDeregisterFromChangeNotification(V1Regn->Rtmv2RegHandle, V1Regn->Rtmv2NotifyHandle); if (Status != NO_ERROR) { break; } if (V1Regn->NotificationEvent) { // Free the lock that serves in syncronization DeleteCriticalSection(&V1Regn->NotificationLock); // Reset the event to indicate no more changes Success = ResetEvent(V1Regn->NotificationEvent); if (!Success) { Status = GetLastError(); break; } } } // // Deregister with RTMv2 using RTMv2 regn handle // Status = RtmDeregisterEntity(V1Regn->Rtmv2RegHandle); if (Status != NO_ERROR) { break; } // // Free resources allocated for the regn wrapper // #if DBG_HDL V1Regn->ObjectHeader.TypeSign = V1_REGN_FREED; #endif FreeObject(V1Regn); return NO_ERROR; } while (FALSE); // // Some error occured - clean up and return status // ASSERT(FALSE); return Status; } DWORD WINAPI RtmAddRoute ( IN HANDLE ClientHandle, IN PVOID Route, IN DWORD TimeToLive, OUT DWORD *Flags OPTIONAL, OUT PVOID CurBestRoute OPTIONAL, OUT PVOID PrevBestRoute OPTIONAL ) /*++ Routine Description: Adds a route to RTMv2 after converting the RTMv1 route to RTMv2 format. We create a next hop object if one does not exist, and add a route through it. Arguments: ClientHandle - RTMv1 registration handle of the caller. Route - Info for V1 route being added/updated. TimeToLive - Time for which the route is kept in RTM before being deleted (value is seconds). THE FOLLOWING PARAMETERS ARE OBSOLETE IN THIS WRAPPER Flags - Returns error if this param is not NULL. CurBestRoute - Returns error if this param is not NULL. PrevBestRoute - Returns error if this param is not NULL. Return Value: Status of the operation. --*/ { PV1_REGN_INFO V1Regn; RTM_NET_ADDRESS DestAddr; RTM_ROUTE_INFO V2RouteInfo; RTM_NEXTHOP_INFO V2NextHopInfo; RTM_NEXTHOP_HANDLE V2NextHop; DWORD ChangeFlags; DWORD Status; VALIDATE_V1_REGN_HANDLE(ClientHandle, &V1Regn); // Protocols specify Flags parameter but don't use it *Flags = RTM_NO_CHANGE; if (ARGUMENT_PRESENT(CurBestRoute) || ARGUMENT_PRESENT(PrevBestRoute)) { return ERROR_NOT_SUPPORTED; } // // Call back into RM to validate route, set priority // Status = V1Globals.PfValidateRouteFunc[V1Regn->ProtocolFamily](Route); if (Status != NO_ERROR) { return Status; } // // Create a new next-hop with this interface // (if this next-hop is not already present) // MakeV2NextHopFromV1Route(V1Regn, Route, &V2NextHopInfo); V2NextHop = NULL; Status = RtmAddNextHop(V1Regn->Rtmv2RegHandle, &V2NextHopInfo, &V2NextHop, &ChangeFlags); if (Status != NO_ERROR) { return Status; } // // Create a new route with the above nexthop // MakeV2RouteFromV1Route(V1Regn, Route, V2NextHop, &DestAddr, &V2RouteInfo); // // Convert TimeToLive for secs to ms // if (TimeToLive != INFINITE) { TimeToLive *= 1000; if (TimeToLive > (MAXTICKS/2-1)) { TimeToLive = MAXTICKS/2-1; } } // Setup flags that control RTMv2's add route ChangeFlags = (V1Regn->Flags & RTM_PROTOCOL_SINGLE_ROUTE) ? RTM_ROUTE_CHANGE_FIRST : 0; // // Add the new route using the RTMv2 API call // Status = RtmAddRouteToDest(V1Regn->Rtmv2RegHandle, NULL, &DestAddr, &V2RouteInfo, TimeToLive, NULL, 0, NULL, &ChangeFlags); // // Remove the handle ref we got on the nexthop above // ASSERT(RtmReleaseNextHops(V1Regn->Rtmv2RegHandle, 1, &V2NextHop) == NO_ERROR); return Status; } DWORD WINAPI RtmDeleteRoute ( IN HANDLE ClientHandle, IN PVOID Route, OUT DWORD *Flags OPTIONAL, OUT PVOID CurBestRoute OPTIONAL ) /*++ Routine Description: Deletes the route in RTMv2 that corresponds to input RTMv1 route. Arguments: ClientHandle - RTMv1 registration handle of the caller. Route - Info for V1 route being deleted in RTM. THE FOLLOWING PARAMETERS ARE OBSOLETE IN THIS WRAPPER Flags - Returns error if this param is not NULL. CurBestRoute - Returns error if this param is not NULL. Return Value: Status of the operation. --*/ { PV1_REGN_INFO V1Regn; RTM_NET_ADDRESS DestAddr; RTM_ROUTE_INFO V2RouteInfo; RTM_ROUTE_HANDLE V2Route; RTM_NEXTHOP_INFO V2NextHopInfo; RTM_NEXTHOP_HANDLE V2NextHop; DWORD ChangeFlags; DWORD Status; VALIDATE_V1_REGN_HANDLE(ClientHandle, &V1Regn); // Protocols specify Flags parameter but don't use it *Flags = RTM_NO_CHANGE; if (ARGUMENT_PRESENT(CurBestRoute)) { return ERROR_NOT_SUPPORTED; } // // Find the next-hop with this interface // MakeV2NextHopFromV1Route(V1Regn, Route, &V2NextHopInfo); V2NextHop = NULL; Status = RtmFindNextHop(V1Regn->Rtmv2RegHandle, &V2NextHopInfo, &V2NextHop, NULL); if (Status != NO_ERROR) { return Status; } // // Delete the route with the above nexthop // MakeV2RouteFromV1Route(V1Regn, Route, V2NextHop, &DestAddr, &V2RouteInfo); // // We can get this route by matching the route's // net addr, its owner and neighbour learnt from // Status = RtmGetExactMatchRoute(V1Regn->Rtmv2RegHandle, &DestAddr, RTM_MATCH_OWNER | RTM_MATCH_NEIGHBOUR, &V2RouteInfo, 0, 0, &V2Route); if (Status == NO_ERROR) { // // Delete the route found above using the handle // Status = RtmDeleteRouteToDest(V1Regn->Rtmv2RegHandle, V2Route, &ChangeFlags); if (Status != NO_ERROR) { // If delete was successful, this deref is automatic ASSERT(RtmReleaseRoutes(V1Regn->Rtmv2RegHandle, 1, &V2Route) == NO_ERROR); } ASSERT(RtmReleaseRouteInfo(V1Regn->Rtmv2RegHandle, &V2RouteInfo) == NO_ERROR); } // // Remove the handle ref we got on the nexthop // ASSERT(RtmReleaseNextHops(V1Regn->Rtmv2RegHandle, 1, &V2NextHop) == NO_ERROR); return Status; } DWORD WINAPI RtmDequeueRouteChangeMessage ( IN HANDLE ClientHandle, OUT DWORD *Flags, OUT PVOID CurBestRoute OPTIONAL, OUT PVOID PrevBestRoute OPTIONAL ) /*++ Routine Description: Removes a route change message (basically a dest that has changed recently) from the client's own queue of pending changes to be notified. If a best route exists on the dest, RTM_CURRENT_BEST_ROUTE is set in flags and CurBestRoute is filled with best info. If the dest has no best routes (in unicast view), then the flags are set to RTM_PREVIOUS_BEST_ROUTE, and a route with correct network address and rest of route info set to some dummy info is returned. At no point are both flags set (as was the case in RTMv1). Arguments: ClientHandle - RTMv1 registration handle of the caller. THESE HAVE A SLIGHTLY DIFFERENT MEANING IN THE WRAPPER Flags - RTM_NO_CHANGE, RTM_PREVIOUS_BEST_ROUTE or RTM_CURRENT_BEST_ROUTE CurBestRoute - Info for current best route is filled. ( See routine description just above ) PrevBestRoute - Info for previous best route is filled. ( See routine description just above ) Return Value: Status of the operation. --*/ { PV1_REGN_INFO V1Regn; PRTM_DEST_INFO DestInfo; PRTM_ROUTE_INFO V2RouteInfo; RTM_ROUTE_HANDLE V2RouteHandle; UINT NumDests; DWORD Status; DWORD Status1; VALIDATE_V1_REGN_HANDLE(ClientHandle, &V1Regn); *Flags = RTM_NO_CHANGE; // Allocate this var-size dest-info on the stack DestInfo = ALLOC_DEST_INFO(V1Regn->Rtmv2NumViews, 1); if (V1Regn->NotificationEvent) { // // This lock serves to make the RtmGetChangedDests // call and resetting of the "more changes" event // a single combined atomic operation, preventing // a case when a set gets lost due to a late reset. // ACQUIRE_V1_NOTIFY_LOCK(V1Regn); } Status = NO_ERROR; NumDests = 0; while (Status == NO_ERROR) { // // Release any destination we got in the prev loop // if (NumDests == 1) { ASSERT(RtmReleaseChangedDests(V1Regn->Rtmv2RegHandle, V1Regn->Rtmv2NotifyHandle, 1, DestInfo) == NO_ERROR); } // // Get the next changed destination for client // NumDests = 1; Status = RtmGetChangedDests(V1Regn->Rtmv2RegHandle, V1Regn->Rtmv2NotifyHandle, &NumDests, DestInfo); if (NumDests < 1) { break; } // // Get the current best route for this dest // V2RouteHandle = DestInfo->ViewInfo[0].Route; if (V2RouteHandle != NULL) { // // We have a best route on the changed dest // Give the caller the new best route info // if (ARGUMENT_PRESENT(CurBestRoute)) { // Get the route's information from RTMv2 V2RouteInfo = ALLOC_ROUTE_INFO(V1Regn->Rtmv2Profile.MaxNextHopsInRoute, 1); Status1 = RtmGetRouteInfo(V1Regn->Rtmv2RegHandle, V2RouteHandle, V2RouteInfo, NULL); if (Status1 != NO_ERROR) { // Best Route would have got deleted - get next change continue; }; Status1 = MakeV1RouteFromV2Route(V1Regn, V2RouteInfo, CurBestRoute); ASSERT(RtmReleaseRouteInfo(V1Regn->Rtmv2RegHandle, V2RouteInfo) == NO_ERROR); if (Status1 != NO_ERROR) { // Best Route would have got changed - get next change continue; } } *Flags = RTM_CURRENT_BEST_ROUTE; } else { // // We have no best route on the changed dest, // Give dummy best route info with this dest // if (ARGUMENT_PRESENT(PrevBestRoute)) { MakeV1RouteFromV2Dest(V1Regn, DestInfo, PrevBestRoute); } *Flags = RTM_PREVIOUS_BEST_ROUTE; } // // Do we have more changes to process here ? // if (Status == ERROR_NO_MORE_ITEMS) { // We have no more changes to notify - reset event if present if (V1Regn->NotificationEvent) { ResetEvent(V1Regn->NotificationEvent); } Status = NO_ERROR; } else { // We have more changes to give out - indicate so in status ASSERT(Status == NO_ERROR); Status = ERROR_MORE_DATA; } break; } if (NumDests == 1) { ASSERT(SUCCESS(RtmReleaseChangedDests(V1Regn->Rtmv2RegHandle, V1Regn->Rtmv2NotifyHandle, 1, DestInfo))); } if (V1Regn->NotificationEvent) { RELEASE_V1_NOTIFY_LOCK(V1Regn); } return Status; } DWORD V2EventCallback ( IN RTM_ENTITY_HANDLE Rtmv2RegHandle, IN RTM_EVENT_TYPE EventType, IN PVOID Context1, IN PVOID Context2 ) /*++ Routine Description: This is the callback function that gets called when any RTMv2 event happens like change notification available, route's timed out etc. Context1 & Context2 contain event specific information. Arguments: Rtmv2RegHandle - Regn handle of entity being informed. EventType - Type of event that caused this call. Context1 - Context associated with this event. Context2 - Context associated with this event. Return Value: Status of the operation being returned to RTMv2 --*/ { PV1_REGN_INFO V1Regn; HANDLE V1RegHandle; V1_ROUTE_INFO CurBestRoute; V1_ROUTE_INFO PrevBestRoute; DWORD Flags; DWORD Status; UNREFERENCED_PARAMETER(Rtmv2RegHandle); UNREFERENCED_PARAMETER(Context1); switch(EventType) { case RTM_CHANGE_NOTIFICATION: V1Regn = (PV1_REGN_INFO) Context2; // // Signal availability of new changes using either callback or event // if (V1Regn->NotificationFunc) { V1RegHandle = MAKE_HANDLE_FROM_POINTER(V1Regn); do { // Get the next change in this regn's queue Status = RtmDequeueRouteChangeMessage(V1RegHandle, &Flags, &CurBestRoute, &PrevBestRoute); if (Status != ERROR_MORE_DATA) { break; } // Call the notification callback with data V1Regn->NotificationFunc(Flags, &CurBestRoute, &PrevBestRoute); } while (TRUE); // Give the final notification call if needed if (Status == NO_ERROR) { // Call the notification callback with data V1Regn->NotificationFunc(Flags, &CurBestRoute, &PrevBestRoute); } } else { // // Set event to signal availability of changes // ASSERT(V1Regn->NotificationEvent); ACQUIRE_V1_NOTIFY_LOCK(V1Regn); SetEvent(V1Regn->NotificationEvent); RELEASE_V1_NOTIFY_LOCK(V1Regn); } return NO_ERROR; case RTM_ROUTE_EXPIRED: // // Do not handle this route expiry notification. // This will automatically cause deletion of the // route and the appropriate change notification // generated and indicated to all the protocols. // return ERROR_NOT_SUPPORTED; } return ERROR_NOT_SUPPORTED; } HANDLE WINAPI RtmCreateEnumerationHandle ( IN DWORD ProtocolFamily, IN DWORD EnumerationFlags, IN PVOID CriteriaRoute ) /*++ Routine Description: Creates an enumeration on routes in RTM that match the appropriate criteria in the input route. This call does not need an RTMv1 registration handle, so we use the wrapper's default V1 registration with RTMv2 to make RTMv2 calls. Matching Routes are returned in the order governed the following fields - ( Dest Address and Mask, Route Preference and Metric ) Arguments: ProtocolFamily - Protocol family of the routes we want EnumerationFlags - Flags indicating the criteria to match CriteriaRoute - The route that we are matching against Return Value: Enumeration Handle or NULL ( GetLastError() to get error ) --*/ { PV1_REGN_INFO V1Regn; RTM_DEST_HANDLE DestHandle; PRTM_DEST_INFO DestInfo; RTM_NET_ADDRESS DestAddr; PV1_ENUM_INFO V1Enum; PVOID Network; RTM_VIEW_SET TargetViews; ULONG TempUlong; DWORD EnumFlags; DWORD MatchFlags; ULONG InterfaceIndex; DWORD Status; // // Validate incoming parameters before action // if ((ProtocolFamily >= RTM_NUM_OF_PROTOCOL_FAMILIES) || (EnumerationFlags & ~(RTM_ONLY_THIS_NETWORK | RTM_ONLY_THIS_PROTOCOL | RTM_ONLY_THIS_INTERFACE | RTM_ONLY_BEST_ROUTES | RTM_ONLY_OWND_ROUTES | RTM_INCLUDE_DISABLED_ROUTES))) { SetLastError(ERROR_INVALID_PARAMETER); return NULL; } // Specify Criteria if these flags are set if ((!ARGUMENT_PRESENT(CriteriaRoute)) && (EnumerationFlags & (RTM_ONLY_THIS_NETWORK | RTM_ONLY_THIS_PROTOCOL | RTM_ONLY_THIS_INTERFACE))) { SetLastError(ERROR_INVALID_PARAMETER); return NULL; } V1Regn = V1Globals.PfRegInfo[ProtocolFamily]; if (V1Regn == NULL) { SetLastError(ERROR_INVALID_HANDLE); return NULL; } // // If we don't need disabled routes, just use unicast view; // or use 0 views to get all routes including disabled ones // if (EnumerationFlags & RTM_INCLUDE_DISABLED_ROUTES) { TargetViews = RTM_VIEW_MASK_ANY; } else { TargetViews = RTM_VIEW_MASK_UCAST; } // // If enuming a certain n/w, check if corr. dest exists // DestHandle = NULL; #if WRN DestInfo = NULL; #endif if (EnumerationFlags & RTM_ONLY_THIS_NETWORK) { V1GetRouteNetwork(CriteriaRoute, ProtocolFamily, &Network); MakeNetAddress(Network, ProtocolFamily, TempUlong, &DestAddr); // Allocate this var-size dest-info on the stack DestInfo = ALLOC_DEST_INFO(V1Regn->Rtmv2NumViews, 1); Status = RtmGetExactMatchDestination(V1Regn->Rtmv2RegHandle, &DestAddr, RTM_BEST_PROTOCOL, TargetViews, DestInfo); if (Status != NO_ERROR) { SetLastError(Status); return NULL; } DestHandle = DestInfo->DestHandle; } do { // // Allocate a V1 enumeration wrapper structure // V1Enum = (PV1_ENUM_INFO) AllocNZeroObject(sizeof(V1_ENUM_INFO)); if (V1Enum == NULL) { Status = ERROR_NOT_ENOUGH_MEMORY; break; } #if DBG_HDL V1Enum->ObjectHeader.TypeSign = V1_ENUM_ALLOC; #endif // // Cache RTMv1 specific params in RTMv1 enum // V1Enum->ProtocolFamily = ProtocolFamily; V1Enum->EnumFlags = EnumerationFlags; if (ARGUMENT_PRESENT(CriteriaRoute)) { // Convert the V1 criteria into V2 criteria V1CopyRoute(V1Enum->CriteriaRoute.Route, CriteriaRoute, ProtocolFamily); } // // Create a route enum on a dest or all dests // if (EnumerationFlags & RTM_ONLY_OWND_ROUTES) { EnumFlags = RTM_ENUM_OWN_ROUTES; } else { EnumFlags = RTM_ENUM_ALL_ROUTES; } MatchFlags = InterfaceIndex = 0; // Do we have to enum's routes on an interface if (EnumerationFlags & RTM_ONLY_THIS_INTERFACE) { MatchFlags = RTM_MATCH_INTERFACE; InterfaceIndex = ((PV1_ROUTE_INFO) CriteriaRoute)->XxRoute.RR_InterfaceID; } Status = RtmCreateRouteEnum(V1Regn->Rtmv2RegHandle, DestHandle, TargetViews, EnumFlags, NULL, MatchFlags, NULL, InterfaceIndex, &V1Enum->Rtmv2RouteEnum); if (Status != NO_ERROR) { break; } // // Initialize lock used to serialize enum ops // try { InitializeCriticalSection(&V1Enum->EnumLock); } except(EXCEPTION_EXECUTE_HANDLER) { Status = ERROR_NOT_ENOUGH_MEMORY; break; } // // Release the destination info as we are done // if (EnumerationFlags & RTM_ONLY_THIS_NETWORK) { ASSERT(SUCCESS(RtmReleaseDestInfo(V1Regn->Rtmv2RegHandle, DestInfo))); } return MAKE_HANDLE_FROM_POINTER(V1Enum); } while (FALSE); // // Some error occurred - clean up and return NULL // if (EnumerationFlags & RTM_ONLY_THIS_NETWORK) { ASSERT(SUCCESS(RtmReleaseDestInfo(V1Regn->Rtmv2RegHandle, DestInfo))); } if (V1Enum) { if (V1Enum->Rtmv2RouteEnum) { ASSERT(SUCCESS(RtmDeleteEnumHandle(V1Regn->Rtmv2RegHandle, V1Enum->Rtmv2RouteEnum))); } #if DBG_HDL V1Enum->ObjectHeader.TypeSign = V1_ENUM_FREED; #endif FreeObject(V1Enum); } SetLastError(Status); return NULL; } DWORD WINAPI RtmEnumerateGetNextRoute ( IN HANDLE EnumerationHandle, OUT PVOID Route ) /*++ Routine Description: Get the next route in the V1 enumeration (satisfying the enumeration critieria). Arguments: EnumerationHandle - Handle that identifies the enumeration Route - Next route is returned in this param Return Value: Status of the operation --*/ { PV1_REGN_INFO V1Regn; RTM_ROUTE_HANDLE V2Route; PV1_ENUM_INFO V1Enum; UINT NumRoutes; BOOL Match; DWORD Status; VALIDATE_V1_ENUM_HANDLE(EnumerationHandle, &V1Enum); V1Regn = V1Globals.PfRegInfo[V1Enum->ProtocolFamily]; // Acquire the enum lock to serialize requests ACQUIRE_V1_ENUM_LOCK(V1Enum); // // Do until you have a matching route or no more routes // Match = FALSE; do { // Get next route in enum, and check if it matches // // Routes are enum'ed in the following order, // Network Addr, Route Priority, Route Metric // NumRoutes = 1; Status = RtmGetEnumRoutes(V1Regn->Rtmv2RegHandle, V1Enum->Rtmv2RouteEnum, &NumRoutes, &V2Route); if (NumRoutes < 1) { break; } Match = MatchCriteriaAndCopyRoute(V1Regn, V2Route, V1Enum, Route); ASSERT(SUCCESS(RtmReleaseRoutes(V1Regn->Rtmv2RegHandle, 1, &V2Route))); } while (!Match); RELEASE_V1_ENUM_LOCK(V1Enum); return Match ? NO_ERROR : Status; } DWORD WINAPI RtmCloseEnumerationHandle ( IN HANDLE EnumerationHandle ) /*++ Routine Description: Closes the enumeration and releases its resources. Arguments: EnumerationHandle - Handle that identifies the enumeration Return Value: Status of the operation --*/ { PV1_REGN_INFO V1Regn; PV1_ENUM_INFO V1Enum; DWORD Status; VALIDATE_V1_ENUM_HANDLE(EnumerationHandle, &V1Enum); V1Regn = V1Globals.PfRegInfo[V1Enum->ProtocolFamily]; do { // // Free the RTMv2 route enumeration and resouces // if (V1Enum->Rtmv2RouteEnum) { Status = RtmDeleteEnumHandle(V1Regn->Rtmv2RegHandle, V1Enum->Rtmv2RouteEnum); ASSERT(Status == NO_ERROR); V1Enum->Rtmv2RouteEnum = NULL; } // // Free resources allocated for the enum wrapper // DeleteCriticalSection(&V1Enum->EnumLock); #if DBG_HDL V1Enum->ObjectHeader.TypeSign = V1_ENUM_FREED; #endif FreeObject(V1Enum); return NO_ERROR; } while (FALSE); ASSERT(FALSE); return Status; } DWORD WINAPI RtmGetFirstRoute ( IN DWORD ProtocolFamily, IN DWORD EnumerationFlags, IN OUT PVOID Route ) /*++ Routine Description: Returns the first route in the table that matches the criteria. This function just opens a new enumeration and gets the first route that matches enumeration critiria, and closes the enumeration. Arguments: ProtocolFamily - Protocol family of the route we want EnumerationFlags - Flags indicating the criteria to match CriteriaRoute - The route that we are matching against Return Value: Status of the operation --*/ { HANDLE V1EnumHandle; DWORD Status; // // Create an enumeration and return the first route in it // V1EnumHandle = RtmCreateEnumerationHandle(ProtocolFamily, EnumerationFlags, Route); if (V1EnumHandle == NULL) { return GetLastError(); } Status = RtmEnumerateGetNextRoute(V1EnumHandle, Route); ASSERT(SUCCESS(RtmCloseEnumerationHandle(V1EnumHandle))); return Status; } DWORD WINAPI RtmGetNextRoute ( IN DWORD ProtocolFamily, IN DWORD EnumerationFlags, OUT PVOID Route ) /*++ Routine Description: Returns the next route in the table that matches the criteria. The routes in RTMv2 are ordered using the following fields - (Dest Address and Mask, Route Preference and Metric) If we have 2 routes with identical values for all the above fields, then you have no way of knowing which of these routes you returned the last time this call was made. For this reason, this call is not supported in this wrapper. One should create an enumeration to actually get the next route in the table. Arguments: ProtocolFamily - Protocol family of the route we want EnumerationFlags - Flags indicating the criteria to match CriteriaRoute - The route that we are matching against Return Value: Status of the operation --*/ { UNREFERENCED_PARAMETER(ProtocolFamily); UNREFERENCED_PARAMETER(EnumerationFlags); UNREFERENCED_PARAMETER(Route); return ERROR_NOT_SUPPORTED; } DWORD WINAPI RtmBlockDeleteRoutes ( IN HANDLE ClientHandle, IN DWORD EnumerationFlags, IN PVOID CriteriaRoute ) /*++ Routine Description: Deletes all routes in the route table that match the criteria specified. Note that if we have multiple instances of a protocol running (say RIP), then each version can delete only the routes in owns. Arguments: ClientHandle - RTM v1 registration handle of caller EnumerationFlags - Flags indicating the criteria to match CriteriaRoute - The route that we are matching against Return Value: Status of the operation --*/ { PV1_REGN_INFO V1Regn; // // Check parameters for validity (in v1 bounds) // VALIDATE_V1_REGN_HANDLE(ClientHandle, &V1Regn); if (EnumerationFlags & ~(RTM_ONLY_THIS_NETWORK | RTM_ONLY_THIS_INTERFACE)) { return ERROR_INVALID_PARAMETER; } // // Deletes only routes of this instance of the protocol // Also include all disabled routes in the enumeration // EnumerationFlags |= (RTM_ONLY_OWND_ROUTES | RTM_INCLUDE_DISABLED_ROUTES); // // Call block operation to delete all matching routes // return BlockOperationOnRoutes(V1Regn, EnumerationFlags, CriteriaRoute, MatchCriteriaAndDeleteRoute); } BOOL MatchCriteriaAndDeleteRoute ( IN PV1_REGN_INFO V1Regn, IN PRTM_ROUTE_HANDLE V2RouteHandle, IN PV1_ENUM_INFO V1Enum ) /*++ Routine Description: Deletes input route if it matches the enumeration criteria. The enumeration criteria returns only routes owned by the caller. See RTM_ONLY_OWND_ROUTES in RtmBlockDeleteRoutes. Arguments: V1Regn - RTM v1 registration info of the caller V2RouteHandle - Handle of the route being considered V1Enum - Enum info that gives matching criteria Return Value: TRUE if you have released input route handle, FALSE if not --*/ { DWORD ChangeFlags; BOOL Match; DWORD Status; Match = MatchCriteria(V1Regn, V2RouteHandle, V1Enum); if (Match) { // Caller can delete the route only if he owns it Status = RtmDeleteRouteToDest(V1Regn->Rtmv2RegHandle, V2RouteHandle, &ChangeFlags); if (Status != NO_ERROR) { ASSERT(FALSE); Match = FALSE; } } return Match; } DWORD WINAPI RtmBlockSetRouteEnable ( IN HANDLE ClientHandle, IN DWORD EnumerationFlags, IN PVOID CriteriaRoute, IN BOOL Enable ) /*++ Routine Description: Enables or disables all routes in the route table that match the criteria specified. Disabling a route removes it from consideration in all best route computations. We do this by adding this route in "no" views in RTMv2. In other words, this route is not considered for best route computations in any views. Note that if we have multiple instances of a protocol running (say RIP), then each version can disable or enable only the routes it owns. Arguments: ClientHandle - RTM v1 registration handle of caller EnumerationFlags - Flags indicating the criteria to match CriteriaRoute - The route that we are matching against Enable - TRUE to enable, and FALSE to disable Return Value: Status of the operation --*/ { PV1_REGN_INFO V1Regn; DWORD *Flags; VALIDATE_V1_REGN_HANDLE(ClientHandle, &V1Regn); if (EnumerationFlags & ~(RTM_ONLY_THIS_NETWORK | RTM_ONLY_THIS_INTERFACE)) { return ERROR_INVALID_PARAMETER; } // Enable/Disable routes only of this instance of the protocol EnumerationFlags |= RTM_ONLY_OWND_ROUTES; // If we are enabling routes, get disable routes too if (Enable) { EnumerationFlags |= RTM_INCLUDE_DISABLED_ROUTES; } // // Set the enable/disable flag in the criteria route // V1GetRouteFlags(CriteriaRoute, V1Regn->ProtocolFamily, Flags); if (Enable) { (*Flags) |= IP_VALID_ROUTE; } else { (*Flags) &= ~IP_VALID_ROUTE; } // // Call block operation to enable/disable all matching routes // return BlockOperationOnRoutes(V1Regn, EnumerationFlags, CriteriaRoute, MatchCriteriaAndEnableRoute); } BOOL MatchCriteriaAndEnableRoute ( IN PV1_REGN_INFO V1Regn, IN PRTM_ROUTE_HANDLE V2RouteHandle, IN PV1_ENUM_INFO V1Enum ) /*++ Routine Description: Enables/disables route if it matches enumeration criteria. We enable or disable a route by adding or removing it from the unicast view, as we assume that v1 protocols understand only the unicast view. This will work only if we enable or disable route owned by caller. Enumeration criteria returns only routes owned by caller. See RTM_ONLY_OWND_ROUTES in RtmBlockSetRouteEnable. Arguments: V1Regn - RTM v1 registration info of the caller V2RouteHandle - Handle of the route being considered V1Enum - Enum info that gives matching criteria Return Value: TRUE if you have released input route handle, FALSE if not --*/ { PRTM_ROUTE_INFO V2RoutePointer; RTM_VIEW_SET Views; DWORD ChangeFlags; BOOL Match; DWORD *Flags; DWORD Status; Match = MatchCriteria(V1Regn, V2RouteHandle, V1Enum); if (!Match) { return FALSE; } do { // Do we need to enable or disable the route ? V1GetRouteFlags(&V1Enum->CriteriaRoute, V1Regn->ProtocolFamily, Flags); // // Remove route from unicast view to disable; // add it back to the unicast view to enable // if ((*Flags) & IP_VALID_ROUTE) { Views = RTM_VIEW_MASK_UCAST; } else { Views = RTM_VIEW_MASK_NONE; } // // Only the route's owner can lock and update it // Status = RtmLockRoute(V1Regn->Rtmv2RegHandle, V2RouteHandle, TRUE, &V2RoutePointer); if (Status != NO_ERROR) { break; } V2RoutePointer->BelongsToViews = Views; // Note that we are not preserving timeout value Status = RtmUpdateAndUnlockRoute(V1Regn->Rtmv2RegHandle, V2RouteHandle, INFINITE, NULL, 0, NULL, &ChangeFlags); if (Status != NO_ERROR) { break; } return FALSE; } while (FALSE); ASSERT(FALSE); return FALSE; } DWORD WINAPI RtmBlockConvertRoutesToStatic ( IN HANDLE ClientHandle, IN DWORD EnumerationFlags, IN PVOID CriteriaRoute ) /*++ Routine Description: Makes the caller the owner of all the routes matching the input criteria. Changing the owner is done by adding a new route for each matching route with the same info. The caller is the owner of the new route. Arguments: ClientHandle - RTM v1 registration handle of caller EnumerationFlags - Flags indicating the criteria to match CriteriaRoute - The route that we are matching against Return Value: Status of the operation --*/ { PV1_REGN_INFO V1Regn; VALIDATE_V1_REGN_HANDLE(ClientHandle, &V1Regn); // // In accordance with RTMv1, act only on enabled routes // EnumerationFlags &= ~RTM_INCLUDE_DISABLED_ROUTES; // // Call block op to add a new route for each matching one. // return BlockOperationOnRoutes(V1Regn, EnumerationFlags, CriteriaRoute, MatchCriteriaAndChangeOwner); } BOOL MatchCriteriaAndChangeOwner ( IN PV1_REGN_INFO V1Regn, IN PRTM_ROUTE_HANDLE V2RouteHandle, IN PV1_ENUM_INFO V1Enum ) /*++ Routine Description: Makes a copy of the route if it matches the enum criteria. The new copy of the route will have the caller as its owner. The matching route can then be deleted (if needed). Arguments: V1Regn - RTM v1 registration info of the caller V2RouteHandle - Handle of the route being considered V1Enum - Enum info that gives matching criteria Return Value: TRUE if you have released input route handle, FALSE if not --*/ { RTM_ENTITY_INFO EntityInfo; PRTM_DEST_INFO DestInfo; PRTM_ROUTE_INFO V2RouteInfo; RTM_NEXTHOP_HANDLE NextHopHandle; RTM_NEXTHOP_HANDLE OldNextHop; RTM_NEXTHOP_HANDLE OldNeighbour; RTM_NEXTHOP_INFO NextHopInfo; RTM_VIEW_SET BestInViews; ULONG Protocol; BOOL Match; DWORD ChangeFlags; DWORD Status; // // Get the route's information from RTMv2 // V2RouteInfo = ALLOC_ROUTE_INFO(V1Regn->Rtmv2Profile.MaxNextHopsInRoute, 1); Status = RtmGetRouteInfo(V1Regn->Rtmv2RegHandle, V2RouteHandle, V2RouteInfo, NULL); if (Status != NO_ERROR) { return FALSE; } Match = FALSE; do { // // Is the route owner already target protocol ? // if (V2RouteInfo->RouteOwner == V1Regn->Rtmv2RegHandle) { break; } // // Does it match the criteria route's protocol ? // if (V1Enum->EnumFlags & RTM_ONLY_THIS_PROTOCOL) { // // Get the protocol type for this route // Status = RtmGetEntityInfo(V1Regn->Rtmv2RegHandle, V2RouteInfo->RouteOwner, &EntityInfo); if (Status != NO_ERROR) { break; } Protocol = EntityInfo.EntityId.EntityProtocolId; Status = RtmReleaseEntityInfo(V1Regn->Rtmv2RegHandle, &EntityInfo); ASSERT(Status == NO_ERROR); // Is this the routing protocol we need ? if (V1Enum->CriteriaRoute.XxRoute.RR_RoutingProtocol != Protocol) { break; } } // // And does it match other criteria in enum ? // if (V1Enum->EnumFlags & RTM_ONLY_BEST_ROUTES) { Status = RtmIsBestRoute(V1Regn->Rtmv2RegHandle, V2RouteHandle, &BestInViews); if ((BestInViews & RTM_VIEW_MASK_UCAST) == 0) { break; } } // // We are checking only the first next hop // as we expect this function to be used // only by V1 protocols on their own routes // ASSERT(V2RouteInfo->NextHopsList.NumNextHops == 1); Status = RtmGetNextHopInfo(V1Regn->Rtmv2RegHandle, V2RouteInfo->NextHopsList.NextHops[0], &NextHopInfo); if (Status != NO_ERROR) { break; } #if DBG // Do we need to match the nexthop intf ? if (V1Enum->EnumFlags & RTM_ONLY_THIS_INTERFACE) { // Compare this next-hops interface with criteria if (NextHopInfo.InterfaceIndex == V1Enum->CriteriaRoute.XxRoute.RR_InterfaceID) { Match = TRUE; } // We have already done this filtering in RTM v2 ASSERT(Match == TRUE); } #endif // Add the same next hop with a different owner if (Match) { NextHopHandle = NULL; do { Status = RtmAddNextHop(V1Regn->Rtmv2RegHandle, &NextHopInfo, &NextHopHandle, &ChangeFlags); if (Status != NO_ERROR) { Match = FALSE; break; } // Allocate this var-size dest-info on the stack DestInfo = ALLOC_DEST_INFO(V1Regn->Rtmv2NumViews, 1); // // Get the destination address corr to handle // Status = RtmGetDestInfo(V1Regn->Rtmv2RegHandle, V2RouteInfo->DestHandle, RTM_BEST_PROTOCOL, RTM_VIEW_ID_UCAST, DestInfo); if (Status != NO_ERROR) { Match = FALSE; break; } // // Add this route again with a different owner // ChangeFlags = (V1Regn->Flags & RTM_PROTOCOL_SINGLE_ROUTE) ? RTM_ROUTE_CHANGE_FIRST : 0; // Update route with new next hop neighbour OldNeighbour = V2RouteInfo->Neighbour; V2RouteInfo->Neighbour = NextHopHandle; // Update route with new forwarding next hop OldNextHop = V2RouteInfo->NextHopsList.NextHops[0]; V2RouteInfo->NextHopsList.NextHops[0] = NextHopHandle; // // Add the new route using the RTMv2 API call // Status = RtmAddRouteToDest(V1Regn->Rtmv2RegHandle, NULL, &DestInfo->DestAddress, V2RouteInfo, INFINITE, NULL, 0, NULL, &ChangeFlags); if (Status != NO_ERROR) { Match = FALSE; } // // Restore old information nexthop information // V2RouteInfo->Neighbour = OldNeighbour; V2RouteInfo->NextHopsList.NextHops[0] = OldNextHop; Status = RtmReleaseDestInfo(V1Regn->Rtmv2RegHandle, DestInfo); ASSERT(Status == NO_ERROR); } while (FALSE); // If we have a next hop handle, release it if (NextHopHandle) { Status = RtmReleaseNextHops(V1Regn->Rtmv2RegHandle, 1, &NextHopHandle); ASSERT(Status == NO_ERROR); } } Status = RtmReleaseNextHopInfo(V1Regn->Rtmv2RegHandle, &NextHopInfo); ASSERT(Status == NO_ERROR); } while (FALSE); #if DELETE_OLD // // Impersonate previous owner and delete his route // if (Match) { Status = RtmDeleteRouteToDest(V2RouteInfo->RouteOwner, V2RouteHandle, &ChangeFlags); if (Status != NO_ERROR) { // Must have been deleted meanwhile - ignore Match = FALSE; } } #else Match = FALSE; #endif ASSERT(SUCCESS(RtmReleaseRouteInfo(V1Regn->Rtmv2RegHandle, V2RouteInfo))); return Match; } DWORD BlockOperationOnRoutes ( IN PV1_REGN_INFO V1Regn, IN DWORD EnumerationFlags, IN PVOID CriteriaRoute, IN PFUNC RouteOperation ) /*++ Routine Description: Performs the route operation specified on each route in the table that matches the enumeration criteria. The route operation is called with the route handle of each matching route. If the operation returns FALSE, then the route handle is released, else it is expected that the handle was released by the operation itself. Arguments: V1Regn - RTM v1 registration info of the caller EnumerationFlags - Flags indicating the criteria to match CriteriaRoute - The route that we are matching against RouteOperation - Operation performed on matching routes Return Value: Status of the operation --*/ { HANDLE V1EnumHandle; PV1_ENUM_INFO V1Enum; PRTM_ROUTE_HANDLE V2RouteHandles; UINT NumRoutes; UINT i; DWORD Status1; DWORD Status; // // Create an enumeration to get all matching routes // V1EnumHandle = RtmCreateEnumerationHandle(V1Regn->ProtocolFamily, EnumerationFlags, CriteriaRoute); if (V1EnumHandle == NULL) { return GetLastError(); } VALIDATE_V1_ENUM_HANDLE(V1EnumHandle, &V1Enum); // // Get list of all matching routes and call operation // // Allocate this var-size handles array on the stack V2RouteHandles = ALLOC_HANDLES(V1Regn->Rtmv2Profile.MaxHandlesInEnum); do { // Get next route in enum, and run operation on it NumRoutes = V1Regn->Rtmv2Profile.MaxHandlesInEnum; Status = RtmGetEnumRoutes(V1Regn->Rtmv2RegHandle, V1Enum->Rtmv2RouteEnum, &NumRoutes, V2RouteHandles); for (i = 0; i < NumRoutes; i++) { if (!RouteOperation(V1Regn, V2RouteHandles[i], V1Enum)) { // Operation not successful - release handle Status1 = RtmReleaseRoutes(V1Regn->Rtmv2RegHandle, 1, &V2RouteHandles[i]); ASSERT(SUCCESS(Status1)); } } } while (Status == NO_ERROR); ASSERT(SUCCESS(RtmCloseEnumerationHandle(V1EnumHandle))); return (Status == ERROR_NO_MORE_ROUTES) ? NO_ERROR : Status; } BOOL MatchCriteriaAndCopyRoute ( IN PV1_REGN_INFO V1Regn, IN PRTM_ROUTE_HANDLE V2RouteHandle, IN PV1_ENUM_INFO V1Enum OPTIONAL, OUT PVOID V1Route OPTIONAL ) /*++ Routine Description: If the input route matches enumeration criteria, it converts to a V1 route and copies it to the output buffer. Arguments: V1Regn - RTM v1 registration info of the caller V2RouteHandle - Handle of the route being considered V1Enum - Enum info that gives matching criteria V1Route - Buffer in which the V1 route is copied Return Value: TRUE if route matches criteria, and FALSE if it does not --*/ { RTM_ENTITY_INFO EntityInfo; PRTM_ROUTE_INFO V2RouteInfo; RTM_VIEW_SET BestInViews; ULONG Protocol; BOOL Match; DWORD Status; // // Get the route's information from RTMv2 // V2RouteInfo = ALLOC_ROUTE_INFO(V1Regn->Rtmv2Profile.MaxNextHopsInRoute, 1); Status = RtmGetRouteInfo(V1Regn->Rtmv2RegHandle, V2RouteHandle, V2RouteInfo, NULL); if (Status != NO_ERROR) { return FALSE; } // // If we have no criteria, we match every route // if (!ARGUMENT_PRESENT(V1Enum)) { Match = TRUE; } else { Match = FALSE; do { if (V1Enum->EnumFlags & RTM_INCLUDE_DISABLED_ROUTES) { // Is route anything but a unicast or disabled one ? if (V2RouteInfo->BelongsToViews & ~RTM_VIEW_MASK_UCAST) { break; } } // // Does it match the criteria route's protocol ? // if (V1Enum->EnumFlags & RTM_ONLY_THIS_PROTOCOL) { // // Get the protocol type for this route // Status = RtmGetEntityInfo(V1Regn->Rtmv2RegHandle, V2RouteInfo->RouteOwner, &EntityInfo); if (Status != NO_ERROR) { break; } Protocol = EntityInfo.EntityId.EntityProtocolId; Status = RtmReleaseEntityInfo(V1Regn->Rtmv2RegHandle, &EntityInfo); ASSERT(Status == NO_ERROR); // Is this the routing protocol we need ? if (V1Enum->CriteriaRoute.XxRoute.RR_RoutingProtocol != Protocol) { break; } } // // And does it match other criteria in enum ? // if (V1Enum->EnumFlags & RTM_ONLY_BEST_ROUTES) { Status = RtmIsBestRoute(V1Regn->Rtmv2RegHandle, V2RouteHandle, &BestInViews); if ((BestInViews & RTM_VIEW_MASK_UCAST) == 0) { break; } } #if DBG if (V1Enum->EnumFlags & RTM_ONLY_THIS_INTERFACE) { RTM_NEXTHOP_INFO NextHopInfo; ULONG IfIndex; // // We are checking only the first next hop // as we expect this function to be used // only by V1 protocols on their own routes // ASSERT(V2RouteInfo->NextHopsList.NumNextHops == 1); Status = RtmGetNextHopInfo(V1Regn->Rtmv2RegHandle, V2RouteInfo->NextHopsList.NextHops[0], &NextHopInfo); if (Status != NO_ERROR) { break; } // Get the interface index for this nexthop IfIndex = NextHopInfo.InterfaceIndex; Status = RtmReleaseNextHopInfo(V1Regn->Rtmv2RegHandle, &NextHopInfo); ASSERT(Status == NO_ERROR); // Is this the interface that we are enum'ing if (IfIndex !=V1Enum->CriteriaRoute.XxRoute.RR_InterfaceID) { // We have already done this filtering in RTM v2 ASSERT(FALSE); break; } } #endif Match = TRUE; } while (FALSE); } // // If we have a match, then make a copy of this route // if (Match) { if (ARGUMENT_PRESENT(V1Route)) { Status = MakeV1RouteFromV2Route(V1Regn, V2RouteInfo, V1Route); if (Status != NO_ERROR) { Match = FALSE; } } } Status = RtmReleaseRouteInfo(V1Regn->Rtmv2RegHandle, V2RouteInfo); ASSERT(Status == NO_ERROR); return Match; } BOOL WINAPI RtmIsRoute ( IN DWORD ProtocolFamily, IN PVOID Network, OUT PVOID BestRoute OPTIONAL ) /*++ Routine Description: Checks the route table corr. to a protocol family for the existence of a route to the input network. Arguments: ProtocolFamily - Protocol family of the route table Network - Network address we are trying to reach BestRoute - Best route to the network is filled Return Value: TRUE if a best route exists, FALSE if not, Use GetLastError to check the status code --*/ { PV1_REGN_INFO V1Regn; RTM_ROUTE_HANDLE V2RouteHandle; PRTM_DEST_INFO DestInfo; RTM_NET_ADDRESS NetAddr; BOOL Match; DWORD Status; // // Validate incoming parameters before action // if (ProtocolFamily >= RTM_NUM_OF_PROTOCOL_FAMILIES) { SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } V1Regn = V1Globals.PfRegInfo[ProtocolFamily]; if (V1Regn == NULL) { SetLastError(ERROR_INVALID_HANDLE); return FALSE; } // Allocate this var-size dest-info on the stack DestInfo = ALLOC_DEST_INFO(V1Regn->Rtmv2NumViews, 1); MakeNetAddress(Network, TempUlong, ProtocolFamily, &NetAddr); Status = RtmGetExactMatchDestination(V1Regn->Rtmv2RegHandle, &NetAddr, RTM_BEST_PROTOCOL, RTM_VIEW_MASK_UCAST, DestInfo); if (Status == NO_ERROR) { // // We have a unicast route to the network // if (ARGUMENT_PRESENT(BestRoute)) { V2RouteHandle = DestInfo->ViewInfo[0].Route; ASSERT(V2RouteHandle != NULL); // We have no criteria; so pass NULL for it Match = MatchCriteriaAndCopyRoute(V1Regn, V2RouteHandle, NULL, BestRoute); ASSERT(Match == TRUE); } Status = RtmReleaseDestInfo(V1Regn->Rtmv2RegHandle, DestInfo); ASSERT(Status == NO_ERROR); return TRUE; } return FALSE; } BOOL WINAPI RtmLookupIPDestination( IN DWORD DestAddr, OUT PRTM_IP_ROUTE IPRoute ) /*++ Routine Description: Gets the best non-loopback IP route to the input destination address. Arguments: DestAddr - Network address of the input dest IPRoute - Best non-loopback route is filled Return Value: TRUE if a best route exists, FALSE if not, Use GetLastError to check the status code --*/ { PV1_REGN_INFO V1Regn; RTM_NET_ADDRESS NetAddr; PRTM_DEST_INFO DestInfo1; PRTM_DEST_INFO DestInfo2; DWORD Status; // // Validate incoming parameters before action // V1Regn = V1Globals.PfRegInfo[RTM_PROTOCOL_FAMILY_IP]; if (V1Regn == NULL) { SetLastError(ERROR_INVALID_HANDLE); return FALSE; } // Allocate this var-size dest-infos on the stack DestInfo1 = ALLOC_DEST_INFO(V1Regn->Rtmv2NumViews, 1); DestInfo2 = ALLOC_DEST_INFO(V1Regn->Rtmv2NumViews, 1); // Convert the V1 addr to a V2 net address format MakeHostAddress((PUCHAR)&DestAddr, RTM_PROTOCOL_FAMILY_IP, &NetAddr); // // Get the best route to the input dest // Status = RtmGetMostSpecificDestination(V1Regn->Rtmv2RegHandle, &NetAddr, RTM_BEST_PROTOCOL, RTM_VIEW_MASK_UCAST, DestInfo1); while (Status == NO_ERROR) { // // Check if this route is a non-loopback one // if (CopyNonLoopbackIPRoute(V1Regn, DestInfo1, IPRoute)) { break; } // // Backtrack up the tree for next best route // Status = RtmGetLessSpecificDestination(V1Regn->Rtmv2RegHandle, DestInfo1->DestHandle, RTM_BEST_PROTOCOL, RTM_VIEW_MASK_UCAST, DestInfo2); ASSERT(SUCCESS(RtmReleaseDestInfo(V1Regn->Rtmv2RegHandle, DestInfo1))); SWAP_POINTERS(DestInfo1, DestInfo2); } if (Status == NO_ERROR) { ASSERT(SUCCESS(RtmReleaseDestInfo(V1Regn->Rtmv2RegHandle, DestInfo1))); return TRUE; } SetLastError(Status); return FALSE; } BOOL CopyNonLoopbackIPRoute ( IN PV1_REGN_INFO V1Regn, IN PRTM_DEST_INFO V2DestInfo, OUT PVOID V1Route ) /*++ Routine Description: Check if the input destination has a non- loopback best route, and if so copy route to the output buffer after conversion to v1 Arguments: V1Regn - RTMv1 Registration info of caller V2DestInfo - Dest whose route we are checking V1Route - Best route is converted to V1 and filled if it is not-loopack Return Value: TRUE if best route is non-loopback, or FALSE --*/ { RTM_ROUTE_HANDLE V2RouteHandle; PRTM_ROUTE_INFO V2RouteInfo; BOOL Match; ULONG Address; DWORD Status; // // Check if the destination addr is loopback // [ Optimized to avoid getting route info ] // Address = * (ULONG *) V2DestInfo->DestAddress.AddrBits; if ((Address & 0x000000FF) == 0x0000007F) { return FALSE; } V2RouteHandle = V2DestInfo->ViewInfo[0].Route; V2RouteInfo = ALLOC_ROUTE_INFO(V1Regn->Rtmv2Profile.MaxNextHopsInRoute, 1); // Get the route's information from RTMv2 Status = RtmGetRouteInfo(V1Regn->Rtmv2RegHandle, V2RouteHandle, V2RouteInfo, NULL); if (Status != NO_ERROR) { return FALSE; }; // If this is a non-loopback route, copy it Match = !(V2RouteInfo->Flags & RTM_ROUTE_FLAGS_LOOPBACK); if (Match) { Status = MakeV1RouteFromV2Route(V1Regn, V2RouteInfo, V1Route); if (Status != NO_ERROR) { Match = FALSE; } } Status = RtmReleaseRouteInfo(V1Regn->Rtmv2RegHandle, V2RouteInfo); ASSERT(Status == NO_ERROR); return Match; } ULONG WINAPI RtmGetNetworkCount ( IN DWORD ProtocolFamily ) /*++ Routine Description: Get the number of networks (same as RTMv2 destinations) in the route table corr. to the input protocol family Arguments: ProtocolFamily - Protocol family of the route table Return Value: Number of destinations, or 0 (Use GetLastError() here) --*/ { RTM_ADDRESS_FAMILY_INFO AddrFamilyInfo; PV1_REGN_INFO V1Regn; UINT NumEntities; DWORD Status; do { // // Validate incoming parameters before action // if (ProtocolFamily >= RTM_NUM_OF_PROTOCOL_FAMILIES) { Status = ERROR_INVALID_PARAMETER; break; } V1Regn = V1Globals.PfRegInfo[ProtocolFamily]; if (V1Regn == NULL) { Status = ERROR_INVALID_HANDLE; break; } // // Query the appropriate table for reqd info // NumEntities = 0; Status = RtmGetAddressFamilyInfo(0, // v1 maps to default Instance ADDRESS_FAMILY[ProtocolFamily], &AddrFamilyInfo, &NumEntities, NULL); if (Status != NO_ERROR) { break; } return AddrFamilyInfo.NumDests; } while (FALSE); // // Some error occured - clean up and return 0 // SetLastError(Status); return 0; } ULONG WINAPI RtmGetRouteAge ( IN PVOID Route ) /*++ Routine Description: Computes the age of the route from its creation time and the current time in seconds. Assumes that the creation time of the route is correctly filled in, which is not the case as we are currently not keeping a FILETIME in the route to save space. If we do keep time, then this function would work without any changes. Arguments: Route - Route whose age we want. Return Value: Age of the route in seconds, or FFFFFFFF (GetLastError gives error in this case). --*/ { ULONGLONG CurTime; // // This code has been directly copied from RTMv1 // GetSystemTimeAsFileTime((FILETIME *)&CurTime); CurTime -= * (PULONGLONG) &(((PRTM_IP_ROUTE)Route)->RR_TimeStamp); if (((PULARGE_INTEGER)&CurTime)->HighPart<10000000) { return (ULONG)(CurTime/10000000); } else { SetLastError (ERROR_INVALID_PARAMETER); return 0xFFFFFFFF; } } // // Common Helper routines // VOID MakeV2RouteFromV1Route ( IN PV1_REGN_INFO V1Regn, IN PVOID V1Route, IN PRTM_NEXTHOP_HANDLE V2NextHop, OUT PRTM_NET_ADDRESS V2DestAddr OPTIONAL, OUT PRTM_ROUTE_INFO V2RouteInfo OPTIONAL ) /*++ Routine Description: Converts a route in RTM v1 format to a route in the RTM v2 format (at present for IP only). The nexthop for the V2 route should have been computed before and passed in as a parameter. Also see function 'MakeV2NextHopFromV1Route'. The function also returns the destination addr along with the RTMv2 route info, as the route info itself does not contain the dest address. Arguments: V1Regn - RTMv1 Registration info of caller V1Route - RTMv1 route being converted to V2 V2NextHop - The V2 nexthop for the V2 route V2DestAddr - V2 destination addr is filled here V2RouteInfo - V2 route information is filled here Return Value: None --*/ { PRTM_IP_ROUTE IPRoute; ULONG TempUlong; // // Do conversion for IP alone (worry about IPX later) // IPRoute = (PRTM_IP_ROUTE) V1Route; if (ARGUMENT_PRESENT(V2RouteInfo)) { ZeroMemory(V2RouteInfo, sizeof(RTM_ROUTE_INFO)); // Fill up the V2 Route Info with V1 info // Assumes caller is owner of the route V2RouteInfo->RouteOwner = V1Regn->Rtmv2RegHandle; V2RouteInfo->Neighbour = V2NextHop; // Should keep all the V1 flags in the V2 route V2RouteInfo->Flags1 = (UCHAR) IPRoute->RR_FamilySpecificData.FSD_Flags; // The only flag we understand is the valid flag // If route is not valid, we add it to no views #if DBG V2RouteInfo->BelongsToViews = RTM_VIEW_MASK_NONE; #endif if (V2RouteInfo->Flags1 & IP_VALID_ROUTE) { V2RouteInfo->BelongsToViews = RTM_VIEW_MASK_UCAST; } if (IsRouteLoopback(IPRoute)) { V2RouteInfo->Flags = RTM_ROUTE_FLAGS_LOOPBACK; } switch (IPRoute->RR_FamilySpecificData.FSD_Type) { case 3: V2RouteInfo->Flags |= RTM_ROUTE_FLAGS_LOCAL; break; case 4: V2RouteInfo->Flags |= RTM_ROUTE_FLAGS_REMOTE; break; } V2RouteInfo->PrefInfo.Preference = IPRoute->RR_FamilySpecificData.FSD_Priority; V2RouteInfo->PrefInfo.Metric = IPRoute->RR_FamilySpecificData.FSD_Metric; // Only the first DWORD is copied by wrapper V2RouteInfo->EntitySpecificInfo = (PVOID) (ULONG_PTR) IPRoute->RR_ProtocolSpecificData.PSD_Data[0]; V2RouteInfo->NextHopsList.NumNextHops = 1; V2RouteInfo->NextHopsList.NextHops[0] = V2NextHop; } // Fill up the V2 Dest Address with V1 info if (ARGUMENT_PRESENT(V2DestAddr)) { MakeNetAddressForIP(&IPRoute->RR_Network, TempUlong, V2DestAddr); } return; } VOID MakeV2NextHopFromV1Route ( IN PV1_REGN_INFO V1Regn, IN PVOID V1Route, OUT PRTM_NEXTHOP_INFO V2NextHopInfo ) /*++ Routine Description: Computes RTMv2 next hop info using the nexthop address and interface index in the RTMv1 route. Arguments: V1Regn - RTMv1 Registration info of caller V1Route - V1 route that is being considered V2NextHopInfo - V2 Next hop info for input route Return Value: None --*/ { PRTM_IP_ROUTE IPRoute; ULONG TempUlong; ZeroMemory(V2NextHopInfo, sizeof(RTM_NEXTHOP_INFO)); // // Do conversion for IP alone (worry about IPX later) // IPRoute = (PRTM_IP_ROUTE) V1Route; // // We ignore the next hop mask in the conversion // // // MakeNetAddressForIP(&IPRoute->RR_NextHopAddress, // TempUlong, // &V2NextHopInfo->NextHopAddress); // UNREFERENCED_PARAMETER(TempUlong); MakeHostAddressForIP(&IPRoute->RR_NextHopAddress, &V2NextHopInfo->NextHopAddress); V2NextHopInfo->NextHopOwner = V1Regn->Rtmv2RegHandle; V2NextHopInfo->InterfaceIndex = IPRoute->RR_InterfaceID; return; } VOID MakeV1RouteFromV2Dest ( IN PV1_REGN_INFO V1Regn, IN PRTM_DEST_INFO DestInfo, OUT PVOID V1Route ) /*++ Routine Description: Fills a V1 route buffer with the destination addr from the V2 route. Arguments: V1Regn - RTMv1 Registration info of caller DestInfo - Destination info in RTMv2 V1Route - V1 route that is being filled in Return Value: None --*/ { PRTM_IP_ROUTE IPRoute; UINT AddrLen; UNREFERENCED_PARAMETER(V1Regn); // // Do conversion for IP alone (worry about IPX later) // IPRoute = (PRTM_IP_ROUTE) V1Route; ZeroMemory(IPRoute, sizeof(RTM_IP_ROUTE)); // // Get the destination addr for this route // IPRoute->RR_Network.N_NetNumber = * (ULONG *) DestInfo->DestAddress.AddrBits; AddrLen = DestInfo->DestAddress.NumBits; ASSERT(AddrLen <= 32); if (AddrLen != 0) { IPRoute->RR_Network.N_NetMask = RtlUlongByteSwap((~0) << (32 - AddrLen)); } // // Fill in dummy family specific data for route // // We make the route the least preferred - by // minimizing its priority and maximizing its // metric - we also treat the route as being // valid and added to the stack - this will // force router manager to delete the route // to this dest in the stack if all routes // to this destination are deleted from RTM. // IPRoute->RR_FamilySpecificData.FSD_Priority = (ULONG) 0; IPRoute->RR_FamilySpecificData.FSD_Metric = IPRoute->RR_FamilySpecificData.FSD_Metric1 = (ULONG) ~0; IPRoute->RR_FamilySpecificData.FSD_Flags = (ULONG) ~0; return; } DWORD MakeV1RouteFromV2Route ( IN PV1_REGN_INFO V1Regn, IN PRTM_ROUTE_INFO V2RouteInfo, OUT PVOID V1Route ) /*++ Routine Description: Converts a route in the RTMv2 format to a V1 route ( at present for IP only ). Arguments: V1Regn - RTMv1 Registration info of caller V2RouteInfo - V2 route information being converted V1Route - Buffer in which V1 route is filled Return Value: Status of the operation --*/ { RTM_ENTITY_INFO EntityInfo; PRTM_DEST_INFO DestInfo; PRTM_IP_ROUTE IPRoute; RTM_NEXTHOP_INFO NextHopInfo; UINT AddrLen; DWORD Status; // // Do conversion for IP alone (worry about IPX later) // IPRoute = (PRTM_IP_ROUTE) V1Route; ZeroMemory(IPRoute, sizeof(RTM_IP_ROUTE)); // // Get the routing protocol for this route // Status = RtmGetEntityInfo(V1Regn->Rtmv2RegHandle, V2RouteInfo->RouteOwner, &EntityInfo); if (Status != NO_ERROR) { return Status; } IPRoute->RR_RoutingProtocol = EntityInfo.EntityId.EntityProtocolId; Status = RtmReleaseEntityInfo(V1Regn->Rtmv2RegHandle, &EntityInfo); ASSERT(Status == NO_ERROR); // // Get the destination addr for this route // // Allocate this var-size dest-info on the stack DestInfo = ALLOC_DEST_INFO(V1Regn->Rtmv2NumViews, 1); Status = RtmGetDestInfo(V1Regn->Rtmv2RegHandle, V2RouteInfo->DestHandle, RTM_BEST_PROTOCOL, RTM_VIEW_ID_UCAST, DestInfo); if (Status != NO_ERROR) { return Status; } IPRoute->RR_Network.N_NetNumber = * (ULONG *) DestInfo->DestAddress.AddrBits; AddrLen = DestInfo->DestAddress.NumBits; ASSERT(AddrLen <= 32); if (AddrLen != 0) { IPRoute->RR_Network.N_NetMask = RtlUlongByteSwap((~0) << (32 - AddrLen)); } Status = RtmReleaseDestInfo(V1Regn->Rtmv2RegHandle, DestInfo); ASSERT(Status == NO_ERROR); // // Get the next hop address and interface // ASSERT(V2RouteInfo->NextHopsList.NumNextHops > 0); Status = RtmGetNextHopInfo(V1Regn->Rtmv2RegHandle, V2RouteInfo->NextHopsList.NextHops[0], &NextHopInfo); if (Status != NO_ERROR) { return Status; } IPRoute->RR_InterfaceID = NextHopInfo.InterfaceIndex; IPRoute->RR_NextHopAddress.N_NetNumber = * (ULONG *) NextHopInfo.NextHopAddress.AddrBits; AddrLen = NextHopInfo.NextHopAddress.NumBits; ASSERT(AddrLen <= 32); if (AddrLen != 0) { IPRoute->RR_NextHopAddress.N_NetMask = RtlUlongByteSwap((~0) >> (32 - AddrLen)); } Status = RtmReleaseNextHopInfo(V1Regn->Rtmv2RegHandle, &NextHopInfo); ASSERT(Status == NO_ERROR); // // Get the family specific data for route // IPRoute->RR_FamilySpecificData.FSD_Priority = V2RouteInfo->PrefInfo.Preference; IPRoute->RR_FamilySpecificData.FSD_Metric = IPRoute->RR_FamilySpecificData.FSD_Metric1 = V2RouteInfo->PrefInfo.Metric; IPRoute->RR_FamilySpecificData.FSD_Flags = V2RouteInfo->Flags1; if (V2RouteInfo->Flags & RTM_ROUTE_FLAGS_LOCAL) { IPRoute->RR_FamilySpecificData.FSD_Type = 3; } else if (V2RouteInfo->Flags & RTM_ROUTE_FLAGS_REMOTE) { IPRoute->RR_FamilySpecificData.FSD_Type = 4; } // // Get the protocol specific data for route // IPRoute->RR_ProtocolSpecificData.PSD_Data[0] = PtrToUlong(V2RouteInfo->EntitySpecificInfo); return NO_ERROR; } #endif // WRAPPER