//============================================================================= // Copyright (c) 1997 Microsoft Corporation // Module Name: Api.c // Abstract: // This module implements some of the Igmp APIs // RegisterProtocol, StartProtocol, StopProtocol, // GetGlobalInfo, SetGlobalInfo, and GetEventMessage // // Author: K.S.Lokesh (lokeshs@) 11-1-97 //============================================================================= #include "pchigmp.h" #pragma hdrstop //------------------------------------------------------------------------------ // Global variables (see global.h for description) //------------------------------------------------------------------------------ DWORD g_Initialized; // interface table, group table, global config, global stats PIGMP_IF_TABLE g_pIfTable; PGROUP_TABLE g_pGroupTable; GLOBAL_CONFIG g_Config; IGMP_GLOBAL_STATS g_Info; // socket wait-event bindings LIST_ENTRY g_ListOfSocketEvents; READ_WRITE_LOCK g_SocketsRWLock; // igmp global timer struct IGMP_TIMER_GLOBAL g_TimerStruct; // protocol handles returned by mgm HANDLE g_MgmIgmprtrHandle; HANDLE g_MgmProxyHandle; // proxy table DWORD g_ProxyIfIndex; PIF_TABLE_ENTRY g_pProxyIfEntry; CRITICAL_SECTION g_ProxyAlertCS; LIST_ENTRY g_ProxyAlertsList; // ras table DWORD g_RasIfIndex; PIF_TABLE_ENTRY g_pRasIfEntry; // global lock, and dynamic locks CRITICAL_SECTION g_CS; DYNAMIC_LOCKS_STORE g_DynamicCSStore; DYNAMIC_LOCKS_STORE g_DynamicRWLStore; // enum lock READ_WRITE_LOCK g_EnumRWLock; // others HANDLE g_ActivitySemaphore; LONG g_ActivityCount; DWORD g_RunningStatus; HINSTANCE g_DllHandle; HANDLE g_RtmNotifyEvent; LOCKED_LIST g_RtmQueue; HANDLE g_Heap; DWORD g_TraceId=INVALID_TRACEID; HANDLE g_LogHandle; // signature for each enumeration USHORT g_GlobalIfGroupEnumSignature; #ifdef MIB_DEBUG DWORD g_MibTraceId; IGMP_TIMER_ENTRY g_MibTimer; #endif //------------------------------------------------------------------------------ // #defines for g_Initialized //------------------------------------------------------------------------------ // // the below flags are used to mark if the data has been initialized. // If a flag is not set, the corresponding structure wont be deinitialized // #define TIMER_GLOBAL_INIT 0x00000002 #define WINSOCK_INIT 0x00000010 #define DYNAMIC_CS_LOCKS_INIT 0x00000020 #define DYNAMIC_RW_LOCKS_INIT 0x00000040 #define GROUP_TABLE_INIT 0x00000080 #define IF_TABLE_INIT 0x00000100 // // flags associated with dll and calls made before start protocol. // these flags should not be reset by start protocol // #define DLL_STARTUP_FLAGS 0xFF000000 // // Is StartProtocol being called immediately after DLL startup. // Used to see if heap has to be destroyed and recreated. // Set in DllStartup() and cleared in ProcolCleanup() as part of StopProtocol() // #define CLEAN_DLL_STARTUP 0x01000000 // flag set to prevent register_protocol from being called multiple times. #define REGISTER_PROTOCOL 0x02000000 //------------------------------------------------------------------------------ // _DLLMAIN // // Called immediately after igmpv2.dll is loaded for the first time by the // process, and when the igmpv2.dll is unloaded by the process. // It does some initialization/final cleanup. // // Calls: _DllStartup() or _DllCleanup() //------------------------------------------------------------------------------ BOOL WINAPI DLLMAIN ( HINSTANCE hModule, DWORD dwReason, LPVOID lpvReserved ) { BOOL bNoErr; DWORD Error=NO_ERROR; switch (dwReason) { // // Startup Initialization of Dll // case DLL_PROCESS_ATTACH: { // disable per-thread initialization DisableThreadLibraryCalls(hModule); // create and initialize global data bNoErr = DllStartup(); break; } // // Cleanup of Dll // case DLL_PROCESS_DETACH: { // free global data bNoErr = DllCleanup(); break; } default: bNoErr = TRUE; break; } return bNoErr; } //end _DLLMAIN //------------------------------------------------------------------------------ // _DllStartup // // Sets the initial igmp status to IGMP_STATUS_STOPPED, creates a private heap, // Does the initialization of the rtm queue and tracing/logging, // and creates the global critical section. // // Note: no structures must be allocated from heap here, as StartProtocol() // if called after StopProtocol() destroys the heap. // Return Values: TRUE (if no error), else FALSE. //------------------------------------------------------------------------------ BOOL DllStartup( ) { BOOL bNoErr; DWORD Error=NO_ERROR; //not required to ZeroMemory igmp global struct as it is a global variable // // set the initial igmp status to stopped. // The status is set to running, after the protocol specific initialization // is completed as part of Start Protocol // g_RunningStatus = IGMP_STATUS_STOPPED; bNoErr = FALSE; BEGIN_BREAKOUT_BLOCK1 { // set the default logging level. It will be reset during // StartProtocol(), when logging level is set as part of global config g_Config.LoggingLevel = IGMP_LOGGING_WARN; // // create a private heap for Igmp // g_Heap = HeapCreate(0, 0, 0); if (g_Heap == NULL) { Error = GetLastError(); GOTO_END_BLOCK1; } try { // initialize the Router Manager event queue CREATE_LOCKED_LIST(&g_RtmQueue); // create global critical section InitializeCriticalSection(&g_CS); } except (EXCEPTION_EXECUTE_HANDLER) { Error = GetExceptionCode(); GOTO_END_BLOCK1; } // igmp has a clean initialization from DLL startup. If StartProtocol // is now called, it does not have to cleanup the heap. g_Initialized |= CLEAN_DLL_STARTUP; bNoErr = TRUE; } END_BREAKOUT_BLOCK1; return bNoErr; } //end _DllStartup //------------------------------------------------------------------------------ // _DllCleanup // // Called when the igmpv2 dll is being unloaded. StopProtocol() would have // been called before, and that would have cleaned all the igmpv2 structures. // This call frees the rtm queue, the global CS, destroys the local heap, // and deregisters tracing/logging. // // Return Value: TRUE //------------------------------------------------------------------------------ BOOL DllCleanup( ) { // destroy the router manager event queue if (LOCKED_LIST_CREATED(&g_RtmQueue)) { DELETE_LOCKED_LIST(&g_RtmQueue, EVENT_QUEUE_ENTRY, Link); } //DebugCheck //DebugScanMemory(); // delete global critical section DeleteCriticalSection(&g_CS); // destroy private heap if (g_Heap != NULL) { HeapDestroy(g_Heap); } // deregister tracing/error logging if (g_LogHandle) RouterLogDeregister(g_LogHandle); if (g_TraceId!=INVALID_TRACEID) TraceDeregister(g_TraceId); return TRUE; } VOID InitTracingAndLogging( ) { BEGIN_BREAKOUT_BLOCK1 { #define REGKEY_TRACING TEXT("Software\\Microsoft\\Tracing\\IGMPv2") #define REGVAL_CONSOLETRACINGMASK TEXT("ConsoleTracingMask") TCHAR szTracing[MAX_PATH]; HKEY pTracingKey; DWORD Value, Error; lstrcpy(szTracing, REGKEY_TRACING); Error = RegOpenKeyEx( HKEY_LOCAL_MACHINE, szTracing, 0, KEY_SET_VALUE, &pTracingKey ); if (Error != ERROR_SUCCESS) GOTO_END_BLOCK1; Value = 0x00ff0000; RegSetValueEx( pTracingKey, REGVAL_CONSOLETRACINGMASK, 0, REG_DWORD, (LPBYTE)&Value, sizeof(DWORD) ); RegCloseKey(pTracingKey); } END_BREAKOUT_BLOCK1; // initialize tracing and error logging if (g_TraceId==INVALID_TRACEID) { g_TraceId = TraceRegister("IGMPv2"); } if (!g_LogHandle) { g_LogHandle = RouterLogRegister("IGMPv2"); } } //------------------------------------------------------------------------------ // _RegisterProtocol // // This is the first function called by the IP Router Manager. // The Router Manager tells the routing protocol its version and capabilities // It also tells the DLL, the ID of the protocol it expects us to // register. This allows one DLL to support multiple routing protocols. // We return the functionality we support and a pointer to our functions. // Return Value: // Error: The error code returned by MGM if registering with it failed // else NO_ERROR //------------------------------------------------------------------------------ DWORD WINAPI RegisterProtocol( IN OUT PMPR_ROUTING_CHARACTERISTICS pRoutingChar, IN OUT PMPR_SERVICE_CHARACTERISTICS pServiceChar ) { DWORD Error = NO_ERROR; // Note: There should not be any trace/logs before here InitTracingAndLogging() ; Trace0(ENTER, "RegisterProtocol()"); // cannot call RegisterProtocol multiple times if (g_Initialized®ISTER_PROTOCOL) { Trace0(ERR, "Error: _RegisterProtocol() called multiple times for igmp"); IgmpAssertOnError(FALSE); return ERROR_CAN_NOT_COMPLETE; } else { g_Initialized |= REGISTER_PROTOCOL; } // // The Router Manager should be calling us to register our protocol. // The Router Manager must be atleast the version we are compiled with // The Router Manager must support routing and multicast. // if(pRoutingChar->dwProtocolId != MS_IP_IGMP) return ERROR_NOT_SUPPORTED; if(pRoutingChar->dwVersion < MS_ROUTER_VERSION) return ERROR_NOT_SUPPORTED; if(!(pRoutingChar->fSupportedFunctionality & RF_ROUTING) || !(pRoutingChar->fSupportedFunctionality & RF_MULTICAST) ) return ERROR_NOT_SUPPORTED; // // We setup our characteristics and function pointers // All pointers should be set to NULL by the caller. // pServiceChar->fSupportedFunctionality = 0; pRoutingChar->fSupportedFunctionality = RF_MULTICAST | RF_ROUTING; pRoutingChar->pfnStartProtocol = StartProtocol; pRoutingChar->pfnStartComplete = StartComplete; pRoutingChar->pfnStopProtocol = StopProtocol; pRoutingChar->pfnAddInterface = AddInterface; pRoutingChar->pfnDeleteInterface = DeleteInterface; pRoutingChar->pfnInterfaceStatus = InterfaceStatus; pRoutingChar->pfnGetEventMessage = GetEventMessage; pRoutingChar->pfnGetInterfaceInfo = GetInterfaceConfigInfo; pRoutingChar->pfnSetInterfaceInfo = SetInterfaceConfigInfo; pRoutingChar->pfnGetGlobalInfo = GetGlobalInfo; pRoutingChar->pfnSetGlobalInfo = SetGlobalInfo; pRoutingChar->pfnMibCreateEntry = MibCreate; pRoutingChar->pfnMibDeleteEntry = MibDelete; pRoutingChar->pfnMibGetEntry = MibGet; pRoutingChar->pfnMibSetEntry = MibSet; pRoutingChar->pfnMibGetFirstEntry = MibGetFirst; pRoutingChar->pfnMibGetNextEntry = MibGetNext; pRoutingChar->pfnUpdateRoutes = NULL; pRoutingChar->pfnConnectClient = ConnectRasClient; pRoutingChar->pfnDisconnectClient = DisconnectRasClient; pRoutingChar->pfnGetNeighbors = GetNeighbors; pRoutingChar->pfnGetMfeStatus = GetMfeStatus; pRoutingChar->pfnQueryPower = NULL; pRoutingChar->pfnSetPower = NULL; Trace0(LEAVE, "Leaving RegisterProtocol():\n"); return NO_ERROR; } //end _RegisterProtocol //------------------------------------------------------------------------------ // _StartProtocol // // Called after the _RegisterProtocol() API. // Initializes the data structures used by the protocol. However, the // protocol actually starts to run when it gets interface ownerships. // Locks: // runs completely in g_CS. // Return Value: // Error: if there is an error else NO_ERROR //------------------------------------------------------------------------------ DWORD WINAPI StartProtocol( IN HANDLE hRtmNotifyEvent, //notify Rtm when protocol stopped IN PSUPPORT_FUNCTIONS pSupportFunctions, //NULL IN PVOID pGlobalConfig, IN ULONG ulStructureVersion, IN ULONG ulStructureSize, IN ULONG ulStructureCount ) { WSADATA WsaData; DWORD Error = NO_ERROR; BOOL bErr; Trace0(ENTER, "Entering StartProtocol()"); // make sure it is not an unsupported igmp version structure if (ulStructureVersion>=IGMP_CONFIG_VERSION_600) { Trace1(ERR, "Unsupported IGMP version structure: %0x", ulStructureVersion); IgmpAssertOnError(FALSE); return ERROR_CAN_NOT_COMPLETE; } // lock retained for entire initialization. so api_entry not required ACQUIRE_GLOBAL_LOCK("_StartProtocol"); // // make certain igmp is not already running // if (g_RunningStatus != IGMP_STATUS_STOPPED) { Trace0(START, "Error: _StartProtocol called when Igmp is already running"); Logwarn0(IGMP_ALREADY_STARTED, NO_ERROR); RELEASE_GLOBAL_LOCK("_StartProtocol"); return ERROR_CAN_NOT_COMPLETE; } bErr = TRUE; BEGIN_BREAKOUT_BLOCK1 { // clear initialization flags set during and after _startProtocol g_Initialized &= DLL_STARTUP_FLAGS; // g_RunningStatus, g_CS, g_TraceId, g_LogHandle, g_RtmQueue, // g_Initialized & 0xFF000000 initialized in DllStartup/RegisterProtocol // // If start protocol has been called after a stop protocol. // if (!(g_Initialized & CLEAN_DLL_STARTUP)) { // destroy private heap, so that there is no memory leak. if (g_Heap != NULL) { HeapDestroy(g_Heap); } // // Reset the igmp global structure. // bugchk:make sure that all appropriate fields are being reset. // g_pIfTable = NULL; g_pGroupTable = NULL; ZeroMemory(&g_Config, sizeof(GLOBAL_CONFIG)); g_Config.LoggingLevel = IGMP_LOGGING_WARN; ZeroMemory(&g_Info, sizeof(IGMP_GLOBAL_STATS)); InitializeListHead(&g_ListOfSocketEvents); ZeroMemory(&g_SocketsRWLock, sizeof(READ_WRITE_LOCK)); ZeroMemory(&g_EnumRWLock, sizeof(READ_WRITE_LOCK)); ZeroMemory(&g_TimerStruct, sizeof(IGMP_TIMER_GLOBAL)); g_MgmIgmprtrHandle = g_MgmProxyHandle = NULL; g_ProxyIfIndex = 0; g_pProxyIfEntry = NULL; ZeroMemory(&g_ProxyAlertCS, sizeof(CRITICAL_SECTION)); InitializeListHead(&g_ProxyAlertsList); g_RasIfIndex = 0; g_pRasIfEntry = NULL; ZeroMemory(&g_DynamicCSStore, sizeof(DYNAMIC_LOCKS_STORE)); ZeroMemory(&g_DynamicRWLStore, sizeof(DYNAMIC_LOCKS_STORE)); g_ActivitySemaphore = NULL; g_ActivityCount = 0; g_RtmNotifyEvent = NULL; g_Heap = NULL; #ifdef MIB_DEBUG g_MibTraceId = 0; ZeroMemory(&g_MibTimer, sizeof(IGMP_TIMER_ENTRY)); #endif // create private heap again. g_Heap = HeapCreate(0, 0, 0); if (g_Heap == NULL) { Error = GetLastError(); Trace1(ANY, "error %d creating Igmp private heap", Error); GOTO_END_BLOCK1; } } // save the Router Manager notification event g_RtmNotifyEvent = hRtmNotifyEvent; // // set the Global Config (after making validation changes) // if(pGlobalConfig == NULL) { Trace0(ERR, "_StartProtocol: Called with NULL global config"); IgmpAssertOnError(FALSE); Error = ERROR_INVALID_PARAMETER; GOTO_END_BLOCK1; } { PIGMP_MIB_GLOBAL_CONFIG pGlobalConfigTmp; pGlobalConfigTmp = (PIGMP_MIB_GLOBAL_CONFIG) pGlobalConfig; // Check the global config, and correct if values are not correct. // Not a fatal error. if (! ValidateGlobalConfig(pGlobalConfigTmp)) { Error = ERROR_INVALID_PARAMETER; GOTO_END_BLOCK1; } g_Config.Version = pGlobalConfigTmp->Version; g_Config.LoggingLevel = pGlobalConfigTmp->LoggingLevel; g_Config.RasClientStats = 1; } // // The Global Stats are set to all 0 as it is a global variable. // // // Initialize Winsock version 2.0 // Error = (DWORD)WSAStartup(MAKEWORD(2,0), &WsaData); if ( (Error!=0) || (LOBYTE(WsaData.wVersion)<2) ) { Trace1(ERR, "StartProtocol: Error %d :could not initialize winsock v-2.0", Error); IgmpAssertOnError(FALSE); Logerr0(WSASTARTUP_FAILED, Error); if (LOBYTE(WsaData.wVersion)<2) WSACleanup(); GOTO_END_BLOCK1; } g_Initialized |= WINSOCK_INIT; // // initialize list of SocketEvents // InitializeListHead(&g_ListOfSocketEvents); Error = CreateReadWriteLock(&g_SocketsRWLock); if (Error!=NO_ERROR) GOTO_END_BLOCK1; Error = CreateReadWriteLock(&g_EnumRWLock); if (Error!=NO_ERROR) GOTO_END_BLOCK1; // // initialize the timer queues and other timer structures // Error = InitializeTimerGlobal(); if (Error!=NO_ERROR) GOTO_END_BLOCK1; g_Initialized |= TIMER_GLOBAL_INIT; // Create Interface Table InitializeIfTable(); g_Initialized |= IF_TABLE_INIT; // Create Group Table InitializeGroupTable(); g_Initialized |= GROUP_TABLE_INIT; // proxy, ras interface already set to 0/NULL in global structure. InitializeListHead(&g_ProxyAlertsList); // // Initialise the Dynamic CS and ReadWrite locks main struct // Error = InitializeDynamicLocksStore(&g_DynamicCSStore); if (Error!=NO_ERROR) GOTO_END_BLOCK1; g_Initialized |= DYNAMIC_CS_LOCKS_INIT; Error = InitializeDynamicLocksStore(&g_DynamicRWLStore); if (Error!=NO_ERROR) GOTO_END_BLOCK1; g_Initialized |= DYNAMIC_RW_LOCKS_INIT; // // create the semaphore released by each thread when it is done // g_ActivityCount already set to 0. // g_ActivityCount = 0; g_ActivitySemaphore = CreateSemaphore(NULL, 0, 0xfffffff, NULL); if (g_ActivitySemaphore == NULL) { Error = GetLastError(); Trace1(ERR, "error %d creating semaphore for Igmp threads", Error); IgmpAssertOnError(FALSE); Logerr0(CREATE_SEMAPHORE_FAILED, Error); GOTO_END_BLOCK1; } // // set the starting time for igmp. Should be done after global // timer and global Info struct are initialized // g_Info.TimeWhenRtrStarted.QuadPart = GetCurrentIgmpTime(); // set igmp status to running g_RunningStatus = IGMP_STATUS_RUNNING; #ifdef MIB_DEBUG // // set delayed timer to display igmp's MIB tables periodically // g_MibTraceId = TraceRegisterEx("IGMPMIB", TRACE_USE_CONSOLE); if (g_MibTraceId != INVALID_TRACEID) { g_MibTimer.Context = NULL; g_MibTimer.Status = TIMER_STATUS_CREATED; g_MibTimer.Function = WT_MibDisplay; #if DEBUG_TIMER_TIMERID SET_TIMER_ID(&g_MibTimer, 910, 0, 0, 0); #endif ACQUIRE_TIMER_LOCK("_StartProtocol"); InsertTimer(&g_MibTimer, 5000, TRUE, DBG_Y); RELEASE_TIMER_LOCK("_StartProtocol"); } #endif //MIB_DEBUG // // register Igmp router with MGM. Proxy will be registered if there // is an active proxy interface. // Error = RegisterProtocolWithMgm(PROTO_IP_IGMP); // no error if I have reached here bErr = FALSE; } END_BREAKOUT_BLOCK1; if (bErr) { Trace1(START, "Igmp could not be started: %d", Error); ProtocolCleanup(); } else { Trace0(START, "Igmp started successfully"); Loginfo0(IGMP_STARTED, NO_ERROR); } g_DllHandle = LoadLibrary(TEXT("igmpv2.dll")); RELEASE_GLOBAL_LOCK("_StartProtocol()"); Trace1(LEAVE, "Leaving StartProtocol():%d\n", Error); return (Error); } //end StartProtocol //------------------------------------------------------------------------------ // _StartComplete // //------------------------------------------------------------------------------ DWORD APIENTRY StartComplete( VOID ) { return NO_ERROR; } //------------------------------------------------------------------------------ // _StopProtocol // // sets the igmp status to stopping, marks the current number of active igmp // work items, and queues a worker that will wait till all those work items // have completed and then clean up igmp structures. This function returns // a pending status to the caller, while the queued work item will notify // the rtm after the cleanup has been done. // Locking: // Runs completely in g_CS. // Return Values: // ERROR_CAN_NOT_COMPLETE, PENDING. // Queues: // _WF_FinishStopProtocol() //------------------------------------------------------------------------------ DWORD APIENTRY StopProtocol( VOID ) { DWORD dwThreadCount, Error=NO_ERROR; Trace0(ENTER, "entering _StopProtocol()"); //debugCheck #if DEBUG_FLAGS_MEM_ALLOC // make sure that no interface timers exist #ifdef MIB_DEBUG if (g_TimerStruct.NumTimers>1) #else if (g_TimerStruct.NumTimers>0) #endif { IgmpAssert(FALSE); DbgPrint("Cleanup: some igmp timers still exist\n"); DebugPrintTimerQueue(); } // make sure that no groups exist DebugForcePrintGroupsList(ENSURE_EMPTY); #endif ACQUIRE_GLOBAL_LOCK("_StopProtocol"); // // cannot stop if already stopped // if (g_RunningStatus != IGMP_STATUS_RUNNING) { Trace0(ERR, "Trying to stop Igmp when it is already being stopped"); IgmpAssertOnError(FALSE); Logerr0(PROTO_ALREADY_STOPPING, NO_ERROR); Trace0(LEAVE, "Leaving _StopProtocol()\n"); RELEASE_GLOBAL_LOCK("_StopProtocol"); return ERROR_CAN_NOT_COMPLETE; } // // set Igmp's status to STOPPING; // this prevents any more work-items from being queued, // and it prevents the one's already queued from executing // InterlockedExchange(&g_RunningStatus, IGMP_STATUS_STOPPING); // // find out how many threads are active in Igmp; // we will have to wait for this many threads to exit // before we clean up Igmp's resources // dwThreadCount = g_ActivityCount; RELEASE_GLOBAL_LOCK("_StopProtocol"); Trace0(LEAVE, "leaving _StopProtocol"); // // QueueUserWorkItem that waits for all active Igmp threads and then // releases resources taken by this DLL. // Note: I dont use QueueIgmpWorker as that would increment the // ActivityCount. // QueueUserWorkItem(WF_FinishStopProtocol, (PVOID)(DWORD_PTR)dwThreadCount, 0); // Note: to be safe, there should be no code after QueueUserWorkItem return ERROR_PROTOCOL_STOP_PENDING; } //end StopProtocol DWORD FreeLibraryThread( PVOID pvContext ) { FreeLibraryAndExitThread(g_DllHandle, 0); return 0; } //------------------------------------------------------------------------------ // WF_FinishStopProtocol //------------------------------------------------------------------------------ DWORD WF_FinishStopProtocol( PVOID pContext //dwThreadCount ) /*++ Routing Description: Waits for all the current active igmp work items to complete. Follows that by a call to ProtocolCleanup() to deregister and cleanup all igmp structures. In the end, notifies RtrManager that the protocol has stopped. Queued by: _StopProtocol() Calls: _ProtocolCleanup() Locks: no locks required as all igmp threads have stopped. --*/ { MESSAGE msg = {0, 0, 0}; DWORD dwThreadCount; DWORD Error = NO_ERROR; Trace0(ENTER1, "entering _WF_FinishStopProtocol()"); // // NOTE: since this is called while the router is stopping, // do not use EnterIgmpWorker()/LeaveIgmpWorker() // dwThreadCount = PtrToUlong(pContext); // // waits for API callers and worker functions to finish // while (dwThreadCount-- > 0) { Trace1(STOP, "%d threads active in Igmp", dwThreadCount+1); WaitForSingleObject(g_ActivitySemaphore, INFINITE); } // enter the critical section and leave, just to be sure that // all threads have quit their calls to LeaveIgmpWorker() ACQUIRE_GLOBAL_LOCK("_WF_FinishStopProtocol"); RELEASE_GLOBAL_LOCK("_WF_FinishStopProtocol"); Trace0(STOP, "all threads stopped. Cleaning up resources"); // // This call deregisters with Wait-Server/MGM, and cleans up // all structures // ProtocolCleanup(); Loginfo0(IGMP_STOPPED, NO_ERROR); // // notify Router Manager that protocol has been stopped // ACQUIRE_LIST_LOCK(&g_RtmQueue, "g_RtmQueue", "_WF_FinishStopProtocol"); EnqueueEvent(&g_RtmQueue, ROUTER_STOPPED, msg); SetEvent(g_RtmNotifyEvent); RELEASE_LIST_LOCK(&g_RtmQueue, "g_RtmQueue", "_WF_FinishStopProtocol"); Trace0(LEAVE1, "Leaving _WF_FinishStopProtocol()"); if (g_DllHandle) { HANDLE h_Thread; h_Thread = CreateThread(0,0,FreeLibraryThread, NULL, 0, NULL); if (h_Thread != NULL) CloseHandle(h_Thread); } return 0; } //end _WF_FinishStopProtocol //------------------------------------------------------------------------------ // _ProtocolCleanup // // All active igmp work items have completed before this procedure is called. // So it is safe to deregister with Wait-Server, and deregister all interfaces/ // RAS clients and Igmp router/proxy protocol with MGM. Then, all the structures // are cleaned up. // // Called by: // _WF_FinishStopProtocol() and _StartProtocol() // Locks: // No locks required as no api can enter when g_RunningStatus set to stopping. //------------------------------------------------------------------------------ VOID ProtocolCleanup( ) { DWORD Error = NO_ERROR; Trace0(ENTER1, "entering _ProtocolCleanup()"); // // Deregister Igmp Router from MGM. Proxy is deregistered if required in // _DeinitializeIfTable // if (g_MgmIgmprtrHandle!=NULL) { Error = MgmDeRegisterMProtocol(g_MgmIgmprtrHandle); Trace1(MGM, "_MgmDeRegisterMProtocol(Igmp): returned %d", Error); } // deregister Mib display #ifdef MIB_DEBUG if (g_MibTraceId != INVALID_TRACEID) TraceDeregister(g_MibTraceId); #endif // close activity semaphore if (g_ActivitySemaphore != NULL) { CloseHandle(g_ActivitySemaphore); g_ActivitySemaphore = NULL; } // DeInitialise the Dynamic CS and ReadWrite locks main struct if (g_Initialized&DYNAMIC_RW_LOCKS_INIT) DeInitializeDynamicLocksStore(&g_DynamicRWLStore, LOCK_TYPE_RW); if (g_Initialized&DYNAMIC_CS_LOCKS_INIT) DeInitializeDynamicLocksStore(&g_DynamicCSStore, LOCK_TYPE_CS); // DeInitialize the group table. Delete the group bucket locks. if (g_Initialized & GROUP_TABLE_INIT) DeInitializeGroupTable(); // DeInitialize InterfaceTable. This call also deregister all interfaces & // ras clients from MGM if (g_Initialized & IF_TABLE_INIT) DeInitializeIfTable(); // DeInitialize the global timer. Deletes the timer critical-section. if (g_Initialized&TIMER_GLOBAL_INIT) DeInitializeTimerGlobal(); // // delete sockets events and deregister them from wait thread. // delete sockets read-write lock // { PLIST_ENTRY pHead, ple; PSOCKET_EVENT_ENTRY psee; HANDLE WaitHandle; pHead = &g_ListOfSocketEvents; for (ple=pHead->Flink; ple!=pHead; ple=ple->Flink) { psee = CONTAINING_RECORD(ple,SOCKET_EVENT_ENTRY,LinkBySocketEvents); if (psee->InputWaitEvent) { WaitHandle = InterlockedExchangePointer(&psee->InputWaitEvent, NULL); if (WaitHandle) UnregisterWaitEx( WaitHandle, NULL ) ; } CloseHandle(psee->InputEvent); } DeleteReadWriteLock(&g_SocketsRWLock); DeleteCriticalSection(&g_ProxyAlertCS); DeleteReadWriteLock(&g_EnumRWLock); } // deinitialize winsock if (g_Initialized & WINSOCK_INIT) { WSACleanup(); } // Mark that _StopProtocol has been called once. // If _StartProtocol is called again, igmp will have to Destroy/Create // private heap and ZeroMemory parts of igmp global struct. g_Initialized &= ~CLEAN_DLL_STARTUP; Trace0(LEAVE1, "leaving _ProtocolCleanup()"); return; } //end _ProtocolCleanup //------------------------------------------------------------------------------ // DebugPrintGlobalConfig //------------------------------------------------------------------------------ VOID DebugPrintGlobalConfig ( PIGMP_MIB_GLOBAL_CONFIG pConfigExt ) { Trace0(CONFIG, "Printing Global Config"); Trace1(CONFIG, "Version: 0x%x", pConfigExt->Version); Trace1(CONFIG, "LoggingLevel: %x\n", pConfigExt->LoggingLevel); } //------------------------------------------------------------------------------ // GetGlobalInfo // // Return Values: ERROR_CAN_NOT_COMPLETE, ERROR_INVALID_DATA, NO_ERROR //------------------------------------------------------------------------------ DWORD WINAPI GetGlobalInfo( IN OUT PVOID pvConfig, IN OUT PDWORD pdwSize, IN OUT PULONG pulStructureVersion, IN OUT PULONG pulStructureSize, IN OUT PULONG pulStructureCount ) { DWORD Error=NO_ERROR, dwSize; PIGMP_MIB_GLOBAL_CONFIG pGlobalConfig; Trace2(ENTER1, "entering GetGlobalInfo(): pvConfig(%08x) pdwSize(%08x)", pvConfig, pdwSize); if (!EnterIgmpApi()) { return ERROR_CAN_NOT_COMPLETE; } BEGIN_BREAKOUT_BLOCK1 { // // check the buffer size and set to global config // if (pdwSize == NULL) { Error = ERROR_INVALID_PARAMETER; GOTO_END_BLOCK1; } if ( (*pdwSize < sizeof(IGMP_MIB_GLOBAL_CONFIG)) || (pvConfig==NULL) ) { Error = ERROR_INSUFFICIENT_BUFFER; } else { pGlobalConfig = (PIGMP_MIB_GLOBAL_CONFIG) pvConfig; pGlobalConfig->Version = g_Config.Version; pGlobalConfig->LoggingLevel = g_Config.LoggingLevel; pGlobalConfig->RasClientStats = g_Config.RasClientStats; } *pdwSize = sizeof(IGMP_MIB_GLOBAL_CONFIG); } END_BREAKOUT_BLOCK1; if (pulStructureCount) *pulStructureCount = 1; if (pulStructureSize) *pulStructureSize = *pdwSize; if (pulStructureVersion) *pulStructureVersion = IGMP_CONFIG_VERSION_500; Trace1(LEAVE1, "Leaving GetGlobalInfo(): %d\n", Error); LeaveIgmpApi(); return Error; } //------------------------------------------------------------------------------ // SetGlobalInfo // Return Values: ERROR_CAN_NOT_COMPLETE, ERROR_INVALID_PARAMETER, // ERROR_INVALID_DATA, NO_ERROR //------------------------------------------------------------------------------ DWORD WINAPI SetGlobalInfo( IN PVOID pvConfig, IN ULONG ulStructureVersion, IN ULONG ulStructureSize, IN ULONG ulStructureCount ) { DWORD Error=NO_ERROR, dwSize; PIGMP_MIB_GLOBAL_CONFIG pConfigSrc; BOOL bValid; if (!EnterIgmpApi()) { return ERROR_CAN_NOT_COMPLETE; } // make sure it is not an unsupported igmp version structure if (ulStructureVersion>=IGMP_CONFIG_VERSION_600) { Trace1(ERR, "Unsupported IGMP version structure: %0x", ulStructureVersion); IgmpAssertOnError(FALSE); LeaveIgmpApi(); return ERROR_CAN_NOT_COMPLETE; } Trace1(ENTER, "entering SetGlobalInfo: pvConfig(%08x)", pvConfig); ASSERT(ulStructureSize == sizeof(IGMP_MIB_GLOBAL_CONFIG)); BEGIN_BREAKOUT_BLOCK1 { if (pvConfig == NULL) { Error = ERROR_INVALID_PARAMETER; GOTO_END_BLOCK1; } pConfigSrc = (PIGMP_MIB_GLOBAL_CONFIG) pvConfig; // validate global config. bValid = ValidateGlobalConfig(pConfigSrc); if (!bValid) { Error = ERROR_INVALID_DATA; GOTO_END_BLOCK1; } // copy from the buffer InterlockedExchange(&g_Config.RasClientStats, pConfigSrc->RasClientStats); InterlockedExchange(&g_Config.LoggingLevel, pConfigSrc->LoggingLevel); } END_BREAKOUT_BLOCK1; Trace1(LEAVE, "leaving SetGlobalInfo(): %d\n", Error); LeaveIgmpApi(); return Error; } //------------------------------------------------------------------------------ // ValidateGlobalConfig // // validates the global config info. If values are not valid, then sets them to // some default values. // // Return Values: // TRUE: if the global config values are valid. // FALSE: if the global config values are not valid. sets default values. //------------------------------------------------------------------------------ BOOL ValidateGlobalConfig( PIGMP_MIB_GLOBAL_CONFIG pGlobalConfig ) { DebugPrintGlobalConfig(pGlobalConfig); // check version if (pGlobalConfig->Version>=IGMP_VERSION_3_5) { Trace1(ERR, "Invalid version in global config.\n" "Create the Igmp configuration again", pGlobalConfig->Version); IgmpAssertOnError(FALSE); Logerr0(INVALID_VERSION, ERROR_INVALID_DATA); return FALSE; } // check loggingLevel switch (pGlobalConfig->LoggingLevel) { case IGMP_LOGGING_NONE : case IGMP_LOGGING_ERROR : case IGMP_LOGGING_WARN : case IGMP_LOGGING_INFO : break; default : pGlobalConfig->LoggingLevel = IGMP_LOGGING_WARN; return FALSE; } // check RasClientStats value if ((pGlobalConfig->RasClientStats!=0)&&(pGlobalConfig->RasClientStats!=1)){ pGlobalConfig->RasClientStats = 0; return FALSE; } return TRUE; } //---------------------------------------------------------------------------- // GetEventMessage // // This is called by the IP Router Manager if we indicate that we have // a message in our queue to be delivered to it (by setting the // g_RtmNotifyEvent) // Return Value // NO_ERROR //---------------------------------------------------------------------------- DWORD APIENTRY GetEventMessage( OUT ROUTING_PROTOCOL_EVENTS *pEvent, OUT PMESSAGE pResult ) { DWORD Error; // // Note: _GetEventMessage() does not use the // EnterIgmpApi()/LeaveIgmpApi() mechanism, // since it may be called after Igmp has stopped, when the // Router Manager is retrieving the ROUTER_STOPPED message // Trace2(ENTER, "entering _GetEventMessage: pEvent(%08x) pResult(%08x)", pEvent, pResult); ACQUIRE_LIST_LOCK(&g_RtmQueue, "RtmQueue", "_GetEventMessage"); Error = DequeueEvent(&g_RtmQueue, pEvent, pResult); RELEASE_LIST_LOCK(&g_RtmQueue, "RtmQueue", "_GetEventMessage"); Trace1(LEAVE, "leaving _GetEventMessage: %d\n", Error); return Error; } //---------------------------------------------------------------------------- // Function: EnqueueEvent // // This function adds an entry to the end of the queue of // Router Manager events. It assumes the queue is locked. //---------------------------------------------------------------------------- DWORD EnqueueEvent( PLOCKED_LIST pQueue, ROUTING_PROTOCOL_EVENTS EventType, MESSAGE Msg ) { DWORD Error; PLIST_ENTRY phead; PEVENT_QUEUE_ENTRY peqe; phead = &pQueue->Link; peqe = IGMP_ALLOC(sizeof(EVENT_QUEUE_ENTRY), 0x1, 0); PROCESS_ALLOC_FAILURE2(peqe, "error %d allocating %d bytes for event queue entry", Error, sizeof(EVENT_QUEUE_ENTRY), return Error); peqe->EventType = EventType; peqe->Msg = Msg; InsertTailList(phead, &peqe->Link); return NO_ERROR; } //------------------------------------------------------------------------------ // Function: DequeueEvent // // This function removes an entry from the head of the queue // of Router Manager events. It assumes the queue is locked //------------------------------------------------------------------------------ DWORD DequeueEvent( PLOCKED_LIST pQueue, ROUTING_PROTOCOL_EVENTS *pEventType, PMESSAGE pMsg ) { PLIST_ENTRY phead, ple; PEVENT_QUEUE_ENTRY peqe; phead = &pQueue->Link; if (IsListEmpty(phead)) { return ERROR_NO_MORE_ITEMS; } ple = RemoveHeadList(phead); peqe = CONTAINING_RECORD(ple, EVENT_QUEUE_ENTRY, Link); *pEventType = peqe->EventType; *pMsg = peqe->Msg; IGMP_FREE(peqe); return NO_ERROR; } //------------------------------------------------------------------------------ // GetNeighbors // Return Values: ERROR_INSUFFICIENT_BUFFER, NO_ERROR //------------------------------------------------------------------------------ DWORD APIENTRY GetNeighbors( IN DWORD dwInterfaceIndex, IN PDWORD pdwNeighborList, IN OUT PDWORD pdwNeighborListSize, OUT PBYTE pbInterfaceFlags ) { PIF_TABLE_ENTRY pite = GetIfByIndex(dwInterfaceIndex); if (IS_QUERIER(pite)) { *pbInterfaceFlags |= MRINFO_QUERIER_FLAG; *pdwNeighborListSize = 0; } else { if (*pdwNeighborListSize < 4) return ERROR_INSUFFICIENT_BUFFER; *pdwNeighborListSize = 4; *pdwNeighborList = pite->Info.QuerierIpAddr; } return NO_ERROR; // no neighbors } //------------------------------------------------------------------------- // GetMfeStatus // // set statusCode to MFE_OIF_PRUNED if the GroupAddr Mcast group is not // joined on the interface, else set it to MFE_NO_ERROR //------------------------------------------------------------------------- DWORD APIENTRY GetMfeStatus( IN DWORD IfIndex, IN DWORD GroupAddr, IN DWORD SourceAddr, OUT PBYTE StatusCode ) { PIF_TABLE_ENTRY pite; PGROUP_TABLE_ENTRY pge; PGI_ENTRY pgie; // by default, set code to group not found on the interface. // if found, set it to MFE_NO_ERROR later on. *StatusCode = MFE_OIF_PRUNED; ACQUIRE_IF_LOCK_SHARED(IfIndex, "_GetMfeStatus"); pite = GetIfByIndex(IfIndex); if (pite!=NULL) { ACQUIRE_GROUP_LOCK(GroupAddr, "_GetMfeStatus"); pge = GetGroupFromGroupTable(GroupAddr, NULL, 0); if (pge!=NULL) { pgie = GetGIFromGIList(pge, pite, 0, ANY_GROUP_TYPE, NULL, 0); if (pgie!=NULL) *StatusCode = MFE_NO_ERROR; } RELEASE_GROUP_LOCK(GroupAddr, "_GetMfeStatus"); } RELEASE_IF_LOCK_SHARED(IfIndex, "_GetMfeStatus"); return NO_ERROR; }