/*++ Copyright (c) 1991 Microsoft Corporation Module Name: netbios.c Abstract: This is the component of netbios that runs in the user process passing requests to \Device\Netbios. Author: Colin Watson (ColinW) 15-Mar-91 Revision History: Ram Cherala (RamC) 31-Aug-95 Added a try/except around the code which calls the post routine in SendAddNcbToDriver function. Currently if there is an exception in the post routine this thread will die before it has a chance to call the "AddNameThreadExit" function to decrement the trhead count. This will result in not being able to shut down the machine without hitting the reset switch. --*/ /* Notes: +-----------+ +------------+ +------------+ | | | | | | | User | | User | | Worker | | Thread 1 | | Thread 2 | | thread in | | | | | | a Post Rtn.| +-----+-----+ +-----+------+ +------+-----+ |Netbios(pncb);|Netbios(pncb); | v v | +-----+--------------+-----------------+------+ | -----> Worker | NETAPI.DLL | WorkQueue thread | | -----> | +--------------------+------------------------+ | +---------+---------+ | | | \Device\Netbios | | | +-------------------+ The netbios Worker thread is created automatically by the Netbios call when it determines that the user threads are calling Netbios() with calls that use a callback routine (called a Post routine in the NetBIOS specification). When a worker thread has been created, all requests will be sent via the WorkQueue to the worker thread for submission to \Device\Netbios. This ensures that send requests go on the wire in the same order as the send ncb's are presented. Because the IO system cancels all a threads requests when it terminates, the use of the worker thread allows such a request inside \Device\Netbios to complete normally. All Post routines are executed by the Worker thread. This allows any Win32 synchronization mechanisms to be used between the Post routine and the applications normal code. The Worker thread terminates when the process exits or when it gets an exception such as an access violation. In addition. If the worker thread gets an addname it will create an extra thread which will process the addname and then die. This solves the problem that the netbios driver will block the users thread during an addname (by calling NtCreateFile) even if the caller specified ASYNCH. The same code is also used for ASTAT which also creates handles and can take a long time now that we support remote adapter status. */ #include #include #include #if defined(UNICODE) #define NETBIOS_SERVICE_NAME L"netbios" #else #define NETBIOS_SERVICE_NAME "netbios" #endif BOOL Initialized; CRITICAL_SECTION Crit; // protects WorkQueue & initialization. LIST_ENTRY WorkQueue; // queue to worker thread. HANDLE Event; // doorbell used when WorkQueue added too. HANDLE WorkerHandle; // Return value when worker thread created. HANDLE WaiterHandle; // Return value when waiter thread created. HANDLE NB; // This processes handle to \Device\Netbios. HANDLE ReservedEvent; // Used for synchronous calls LONG EventUse; // Prevents simultaneous use of ReservedEvent HANDLE AddNameEvent; // Doorbell used when an AddName worker thread // exits. volatile LONG AddNameThreadCount; // // Event used to wait for STOP notification from the Kernel mode NETBIOS.SYS // HANDLE StopEvent; IO_STATUS_BLOCK StopStatusBlock; #if AUTO_RESET // // Event used to wait for RESET notification from the Kernel mode NETBIOS.SYS // Adapters // CRITICAL_SECTION ResetCS; // protects access to LanaResetList LIST_ENTRY LanaResetList; NCB OutputNCB; HANDLE LanaResetEvent; // Event signalled when a new adapter is // bound to netbios and it needs to be reset IO_STATUS_BLOCK ResetStatusBlock; #endif HMODULE g_hModule; // // netbios command history // NCB_INFO g_QueuedHistory[16]; DWORD g_dwNextQHEntry = 0; NCB_INFO g_DeQueuedHistory[16]; DWORD g_dwNextDQHEntry = 0; NCB_INFO g_SyncCmdsHistory[16]; DWORD g_dwNextSCEntry = 0; VOID SpinUpAddnameThread( IN PNCBI pncb ); VOID AddNameThreadExit( VOID ); DWORD SendAddNcbToDriver( IN PVOID Context ); DWORD StartNetBIOSDriver( VOID ); #if AUTO_RESET VOID ResetLanaAndPostListen( ); #endif NTSTATUS StartNB( OUT OBJECT_ATTRIBUTES *pobjattr, IN UNICODE_STRING *punicode, OUT IO_STATUS_BLOCK *piosb ) /*++ Routine Description: This routine is a worker function of Netbios. It will try to start NB service. Arguments: OUT pobjattr - object attribute IN punicode - netbios file name OUT piosb - ioblock Return Value: The function value is the status of the operation. --*/ { // // Open a handle to \\Device\Netbios // InitializeObjectAttributes( pobjattr, // obj attr to initialize punicode, // string to use OBJ_CASE_INSENSITIVE, // Attributes NULL, // Root directory NULL); // Security Descriptor return NtCreateFile( &NB, // ptr to handle GENERIC_READ // desired... | GENERIC_WRITE, // ...access pobjattr, // name & attributes piosb, // I/O status block. NULL, // alloc size. FILE_ATTRIBUTE_NORMAL, FILE_SHARE_DELETE // share... | FILE_SHARE_READ | FILE_SHARE_WRITE, // ...access FILE_OPEN_IF, // create disposition 0, // ...options NULL, // EA buffer 0L ); // Ea buffer len } unsigned char APIENTRY Netbios( IN PNCB pncb ) /*++ Routine Description: This routine is the applications entry point into netapi.dll to support netbios 3.0 conformant applications. Arguments: IN PNCB pncb- Supplies the NCB to be processed. Contents of the NCB and buffers pointed to by the NCB will be modified in conformance with the netbios 3.0 specification. Return Value: The function value is the status of the operation. Notes: The reserved field is used to hold the IO_STATUS_BLOCK. Even if the application specifies ASYNCH, the thread may get blocked for a period of time while we open transports, create worker threads etc. --*/ { // // pncbi saves doing lots of type casting. The internal form includes // the use of the reserved fields. // PNCBI pncbi = (PNCBI) pncb; NTSTATUS ntStatus; BOOL bPending = FALSE; if ( ((ULONG_PTR)pncbi & 3) != 0) { // // NCB must be 32 bit aligned // pncbi->ncb_retcode = pncbi->ncb_cmd_cplt = NRC_BADDR; return NRC_BADDR; } // // using this field to fix bug # 293765 // pncbi-> ncb_reserved = 0; // // Conform to Netbios 3.0 specification by flagging request in progress // pncbi->ncb_retcode = pncbi->ncb_cmd_cplt = NRC_PENDING; DisplayNcb( pncbi ); if ( !Initialized ) { EnterCriticalSection( &Crit ); // // Check again to see if another thread got into the critical section // and initialized the worker thread. // if ( !Initialized ) { IO_STATUS_BLOCK iosb; OBJECT_ATTRIBUTES objattr; UNICODE_STRING unicode; HANDLE Threadid; BOOL Flag; // // 1. start netbios driver // // // Open handle to \\Device\Netbios // RtlInitUnicodeString( &unicode, NB_DEVICE_NAME); ntStatus = StartNB( &objattr, &unicode, &iosb ); if ( !NT_SUCCESS( ntStatus ) ) { // // Load the driver // DWORD err = 0; err = StartNetBIOSDriver(); if ( err ) { pncbi->ncb_retcode = NRC_OPENERR; pncbi->ncb_cmd_cplt = NRC_OPENERR; NbPrintf( ( "[NETAPI32] Failed to load driver : %lx\n", err )); LeaveCriticalSection( &Crit ); return pncbi->ncb_cmd_cplt; } else { // // Driver loaded. // Open handle to \\Device\Netbios // ntStatus = StartNB( &objattr, &unicode, &iosb ); if ( !NT_SUCCESS( ntStatus ) ) { pncbi->ncb_retcode = NRC_OPENERR; pncbi->ncb_cmd_cplt = NRC_OPENERR; NbPrintf( ( "[NETAPI32] Failed to open handle : %X\n", ntStatus )); LeaveCriticalSection( &Crit ); return pncbi->ncb_cmd_cplt; } } } // // 2. create a reserved (reusable) event for internal use // ntStatus = NtCreateEvent( &ReservedEvent, EVENT_ALL_ACCESS, NULL, SynchronizationEvent, FALSE ); if ( !NT_SUCCESS( ntStatus) ) { pncbi->ncb_retcode = NRC_SYSTEM; pncbi->ncb_cmd_cplt = NRC_SYSTEM; NbPrintf( ( "[NETAPI32] Failed to create Reserved Event : %X\n", ntStatus ) ); LeaveCriticalSection( &Crit ); NtClose( NB ); NB = NULL; return pncbi->ncb_cmd_cplt; } EventUse = 1; // // Initialize shared datastructures // // // create a queue for work items to be queued to the Worker thread // InitializeListHead( &WorkQueue ); // // 4. create an event to communicate with the Worker thread // ntStatus = NtCreateEvent( &Event, EVENT_ALL_ACCESS, NULL, SynchronizationEvent, FALSE ); if ( !NT_SUCCESS( ntStatus ) ) { pncbi->ncb_retcode = NRC_SYSTEM; pncbi->ncb_cmd_cplt = NRC_SYSTEM; NbPrintf( ( "[NETAPI32] Failed to create Event : %X\n", ntStatus ) ); LeaveCriticalSection( &Crit ); NtClose( ReservedEvent ); NtClose( NB ); NB = NULL; return pncbi->ncb_cmd_cplt; } // // 5. // create an event to synchronize ADD name operations with // Lana Reset operations. Both these are performed in separate // threads and RESET operations are gated by the ADD names // ntStatus = NtCreateEvent( &AddNameEvent, EVENT_ALL_ACCESS, NULL, NotificationEvent, FALSE ); if ( !NT_SUCCESS( ntStatus ) ) { pncbi->ncb_retcode = NRC_SYSTEM; pncbi->ncb_cmd_cplt = NRC_SYSTEM; NbPrintf( ( "[NETAPI32] Failed to create AddName Event : %X\n", ntStatus ) ); LeaveCriticalSection( &Crit ); NtClose( Event ); NtClose( ReservedEvent ); NtClose( NB ); NB = NULL; return pncbi->ncb_cmd_cplt; } // // 6. Create an event to register for stop notification. // ntStatus = NtCreateEvent( &StopEvent, EVENT_ALL_ACCESS, NULL, SynchronizationEvent, FALSE ); if ( !NT_SUCCESS( ntStatus ) ) { pncbi->ncb_retcode = NRC_SYSTEM; pncbi->ncb_cmd_cplt = NRC_SYSTEM; NbPrintf( ( "[NETAPI32] Failed to create StopEvent Event : %X\n", ntStatus ) ); LeaveCriticalSection( &Crit ); NtClose( AddNameEvent ); NtClose( Event ); NtClose( ReservedEvent ); NtClose( NB ); NB = NULL; return pncbi->ncb_cmd_cplt; } #if AUTO_RESET // // 7. Create an event to register for reset notification. // ntStatus = NtCreateEvent( &LanaResetEvent, EVENT_ALL_ACCESS, NULL, SynchronizationEvent, FALSE ); if ( !NT_SUCCESS( ntStatus ) ) { pncbi->ncb_retcode = NRC_SYSTEM; pncbi->ncb_cmd_cplt = NRC_SYSTEM; NbPrintf( ( "[NETAPI32] Failed to create StopEvent Event : %X\n", ntStatus ) ); LeaveCriticalSection( &Crit ); NtClose( StopEvent ); NtClose( AddNameEvent ); NtClose( Event ); NtClose( ReservedEvent ); NtClose( NB ); NB = NULL; return pncbi->ncb_cmd_cplt; } #endif // // 8. create a worker thread to handle async. Netbios requests // { TCHAR szFileName[MAX_PATH + 1]; GetModuleFileName(g_hModule, szFileName, sizeof(szFileName) / sizeof(TCHAR)); LoadLibrary(szFileName); } WaiterHandle = CreateThread( NULL, // Standard thread attributes 0, // Use same size stack as users // application NetbiosWaiter, // Routine to start in new thread 0, // Parameter to thread 0, // No special CreateFlags (LPDWORD)&Threadid ); if ( WaiterHandle == NULL ) { pncbi->ncb_retcode = NRC_SYSTEM; pncbi->ncb_cmd_cplt = NRC_SYSTEM; NbPrintf( ( "[NETAPI32] Failed to create Waiter thread" ) ); LeaveCriticalSection( &Crit ); NtClose( StopEvent ); NtClose( AddNameEvent ); NtClose( Event ); NtClose( ReservedEvent ); NtClose( NB ); NB = NULL; return pncbi->ncb_cmd_cplt; } NbPrintf( ( "Waiter handle: %lx, threadid %lx\n", WaiterHandle, Threadid ) ); } Initialized = TRUE; LeaveCriticalSection( &Crit ); } // // Verify that handle to \\Device\Netbios is still open. // if ( NB == NULL ) { pncbi->ncb_retcode = NRC_OPENERR; pncbi->ncb_cmd_cplt = NRC_OPENERR; NbPrintf( ("[NETAPI32] Netbios service has been stopped\n") ); return pncbi->ncb_cmd_cplt; } // // Disallow simultaneous use of both event and callback routine. // This will cut down the test cases by disallowing a weird feature. // if ( ( ( pncbi->ncb_command & ASYNCH) != 0) && ( pncbi->ncb_event) && ( pncbi->ncb_post ) ) { pncbi->ncb_retcode = NRC_ILLCMD; pncbi->ncb_cmd_cplt = NRC_ILLCMD; NbPrintf( ( "[NETAPI32] Event and Post Routine specified\n" ) ); return pncbi->ncb_cmd_cplt; } // // if synchronous command // if ( (pncb->ncb_command & ASYNCH) == 0 ) { NTSTATUS Status; LONG EventOwned; // NbPrint( ("[NETAPI32] Synchronpus netbios call\n") ); // // Caller wants a synchronous call so ignore ncb_post and ncb_event. // // We need an event so that we can pause if STATUS_PENDING is returned. // EventOwned = InterlockedDecrement( &EventUse ); // // If EventUse went from 1 to 0 then we obtained ReservedEvent // if ( EventOwned == 0) { pncbi->ncb_event = ReservedEvent; } else { InterlockedIncrement( &EventUse ); Status = NtCreateEvent( &pncbi->ncb_event, EVENT_ALL_ACCESS, NULL, SynchronizationEvent, FALSE ); if ( !NT_SUCCESS( Status ) ) { // // Failed to create event // pncbi->ncb_retcode = NRC_SYSTEM; pncbi->ncb_cmd_cplt = NRC_SYSTEM; NbPrintf( ( "[NETAPI32] Failed to create event : %X\n", Status ) ); return pncbi->ncb_cmd_cplt; } } pncbi-> ncb_post = NULL; // // Check if the worker thread has been created. If it has queue workitem // to it. Else use the caller's thread to execute synchronous NCB command // if ( WorkerHandle == NULL ) { ADD_SYNCCMD_ENTRY(pncbi); // // Worker thread has not been created. Execute in the context of // invoker's thread. // SendNcbToDriver( pncbi ); } else { // // Queue Netbios command to worker thread and wait for APC to fire // QueueToWorker( pncbi ); } do { ntStatus = NtWaitForSingleObject( pncbi->ncb_event, TRUE, NULL ); } while ( ( ntStatus == STATUS_USER_APC ) || ( ntStatus == STATUS_ALERTED) ); ASSERT( ntStatus == STATUS_SUCCESS ); if ( !NT_SUCCESS(ntStatus) ) { NbPrintf(( "[NETAPI32] NtWaitForSingleObject failed: %X\n", ntStatus ) ); pncbi->ncb_retcode = NRC_SYSTEM; pncbi->ncb_cmd_cplt = NRC_SYSTEM; } // // release the local event used to wait for // completion of netbios command // if ( EventOwned == 0) { InterlockedIncrement( &EventUse ); } else { NtClose( pncbi->ncb_event ); } pncbi-> ncb_event = NULL; } else { // // Async netbios command. Queue to worker thread // // // Check if worker exists. // if ( WorkerHandle == NULL ) { EnterCriticalSection( &Crit ); // // verify that worker thread has not been created by // while this thread was waiting in EnterCriticalSection // if ( WorkerHandle == NULL ) { HANDLE Threadid; BOOL Flag; // // create a worker thread to handle async. Netbios requests // WorkerHandle = CreateThread( NULL, // Standard thread attributes 0, // Use same size stack as users // application NetbiosWorker, // Routine to start in new thread 0, // Parameter to thread 0, // No special CreateFlags (LPDWORD)&Threadid ); if ( WorkerHandle == NULL ) { pncbi->ncb_retcode = NRC_SYSTEM; pncbi->ncb_cmd_cplt = NRC_SYSTEM; NbPrintf( ( "[NETAPI32] Failed to create Worker thread" ) ); LeaveCriticalSection( &Crit ); return pncbi->ncb_cmd_cplt; } Flag = SetThreadPriority( WorkerHandle, THREAD_PRIORITY_ABOVE_NORMAL ); ASSERT( Flag == TRUE ); if ( Flag != TRUE ) { NbPrintf( ("[NETAPI32] Worker SetThreadPriority: %lx\n", GetLastError() ) ); } AddNameThreadCount = 0; NbPrintf( ( "Worker handle: %lx, threadid %lx\n", WorkerHandle, Threadid ) ); } LeaveCriticalSection( &Crit ); } // NbPrint( ("[NETAPI32] Asynchronpus netbios call\n") ); bPending = TRUE; QueueToWorker( pncbi ); } switch ( pncb->ncb_command & ~ASYNCH ) { case NCBRECV: case NCBRECVANY: case NCBDGRECV: case NCBDGSENDBC: case NCBDGRECVBC: case NCBENUM: case NCBASTAT: case NCBSSTAT: case NCBCANCEL: case NCBCALL: DisplayNcb( pncbi ); } if ( bPending ) { return NRC_GOODRET; } else { return pncbi->ncb_cmd_cplt; } } // NetBios DWORD StartNetBIOSDriver( VOID ) /*++ Routine Description: Starts the netbios.sys driver using the service controller Arguments: none Returns: Error return from service controller. ++*/ { DWORD err = NO_ERROR; SC_HANDLE hSC; SC_HANDLE hSCService; hSC = OpenSCManager( NULL, NULL, SC_MANAGER_CONNECT ); if (hSC == NULL) { return(GetLastError()); } hSCService = OpenService( hSC, NETBIOS_SERVICE_NAME, SERVICE_START ); if (hSCService == NULL) { CloseServiceHandle(hSC); return(GetLastError()); } if ( !StartService( hSCService, 0, NULL ) ) { err = GetLastError(); } CloseServiceHandle(hSCService); CloseServiceHandle(hSC); if ( err ) { NbPrintf( ("[NETAPI32] LEAVING StartNetBIOSDriver, Error : %d\n", err) ); } return(err); } VOID QueueToWorker( IN PNCBI pncb ) /*++ Routine Description: This routine queues an ncb to the worker thread. Arguments: IN PNCBI pncb - Supplies the NCB to be processed. Contents of the NCB and buffers pointed to by the NCB will be modified in conformance with the netbios 3.0 specification. Return Value: The function value is the status of the operation. --*/ { if ( pncb->ncb_event != NULL ) { NtResetEvent( pncb->ncb_event, NULL ); } EnterCriticalSection( &Crit ); if ( pncb-> ncb_reserved == 0 ) { InsertTailList( &WorkQueue, &pncb->u.ncb_next ); pncb-> ncb_reserved = 1; // // Note queued distory // ADD_QUEUE_ENTRY(pncb); } LeaveCriticalSection( &Crit ); // Make sure the worker is awake to perform the request NtSetEvent(Event, NULL); } #if _MSC_FULL_VER >= 13008827 #pragma warning(push) #pragma warning(disable:4715) // Not all control paths return (due to infinite loop) #endif DWORD NetbiosWorker( IN LPVOID Parameter ) /*++ Routine Description: This routine processes ASYNC requests made with the callback interface. The reasons for using a seperate thread are: 1) If a thread makes an async request and exits while the request is outstanding then the request will be cancelled by the IO system. 2) A seperate thread must be used so that the users POST routine can use normal synchronization APIs to access shared data structures. If the users thread is used then deadlock can and will happen. The POST routine operates in the context of the worker thread. There are no restrictions on what the POST routine can do. For example it can submit another ASYNCH request if desired. It will add it to the queue of work and set the event as normal. The worker thread will die when the process terminates. Arguments: IN PULONG Parameter - supplies an unused parameter. Return Value: none. --*/ { NTSTATUS Status; while ( TRUE) { // // Wait for a request to be placed onto the work queue. // // // Must wait alertable so that the Apc (post) routine is called. // Status = NtWaitForSingleObject( Event, TRUE, NULL ); if ( ( Status == STATUS_SUCCESS ) && ( NB != NULL ) ) { EnterCriticalSection( &Crit ); // // remove each Netbios request and forward it to the NETBIOS driver // while ( !IsListEmpty( &WorkQueue ) ) { PLIST_ENTRY entry; PNCBI pncb; entry = RemoveHeadList(&WorkQueue); // // Zero out reserved field again // entry->Flink = entry->Blink = 0; pncb = CONTAINING_RECORD( entry, NCBI, u.ncb_next ); ADD_DEQUEUE_ENTRY(pncb); LeaveCriticalSection( &Crit ); // Give ncb to the driver specifying the callers APC routine if ( (pncb->ncb_command & ~ASYNCH) == NCBRESET ) { // // We may have threads adding names. Wait until // they are complete before submitting the reset. // Addnames and resets are rare so this should rarely // affect an application. // EnterCriticalSection( &Crit ); NtResetEvent( AddNameEvent, NULL ); while ( AddNameThreadCount != 0 ) { LeaveCriticalSection( &Crit ); NtWaitForSingleObject( AddNameEvent, TRUE, NULL ); EnterCriticalSection( &Crit ); NtResetEvent( AddNameEvent, NULL ); } LeaveCriticalSection( &Crit ); } // // SendNcbToDriver must not be in a critical section since the // request may block if its a non ASYNCH request. // if (( (pncb->ncb_command & ~ASYNCH) != NCBADDNAME ) && ( (pncb->ncb_command & ~ASYNCH) != NCBADDGRNAME ) && ( (pncb->ncb_command & ~ASYNCH) != NCBASTAT )) { SendNcbToDriver( pncb ); } else { SpinUpAddnameThread( pncb ); } EnterCriticalSection( &Crit ); } LeaveCriticalSection( &Crit ); } else if ( NB == NULL ) { } } return 0; UNREFERENCED_PARAMETER( Parameter ); } DWORD NetbiosWaiter( IN LPVOID Parameter ) /*++ Routine Description: This routine pends IOCTLs with the kernel mde component of Netbios and wait for them to complete. The reason for a separate thread is that these IOCTLs cannot be pended in the context of the user threads as exiting the user thread will cause the IOCTL to get cancelled. In addition this thread is created at Netbios initialization (refer Netbios function) which could (and is) called from the DLL main of applications. So the initialization code cannot wait for this thread to be created and initialized due to NT serialization of library loads and thread creation. To merge this thread with the Worker thread was deemed risky. To do this the worker thread would execute all ASYNC requests and SYNC requests would be executed in the context of the user's thread. This was a break from the the previous model where the once the Worker thread was created all requests (ASYNC and SYNC) would be executed in the context of the worker thread. To preserve the previous mode of operation a separate wait thread was created. **** There may be a better way to do this **** with only one thread but I am not sure. Arguments: IN PULONG Parameter - supplies an unused parameter. Return Value: none. --*/ { #if AUTO_RESET #define POS_STOP 0 #define POS_RESET 1 #endif NTSTATUS Status; // // Send an IOCTL down to the kernel mode Netbios driver, to register // for stop notification. This call should return STATUS_PENDING. // The event specified "StopEvent" will be signalled when the netbios // driver is being unloaded. // Status = NtDeviceIoControlFile( NB, StopEvent, NULL, NULL, &StopStatusBlock, IOCTL_NB_REGISTER_STOP, NULL, 0, NULL, 0 ); if ( ( Status != STATUS_PENDING ) && ( Status != STATUS_SUCCESS ) ) { NbPrintf( ("[NETAPI32] : Netbios IOCTL for STOP failed with status %lx\n", Status) ); } #if AUTO_RESET Status = NtDeviceIoControlFile( NB, LanaResetEvent, NULL, NULL, &ResetStatusBlock, IOCTL_NB_REGISTER_RESET, NULL, 0, (PVOID) &OutputNCB, sizeof( NCB ) ); if ( ( Status != STATUS_PENDING ) && ( Status != STATUS_SUCCESS ) ) { // // Failed to register reset notification. // NbPrintf( ("[NETAPI32] : Netbios : Failed to register Reset event\n" ) ); } #endif while ( TRUE ) { #if AUTO_RESET HANDLE Events[] = { StopEvent, LanaResetEvent }; Status = NtWaitForMultipleObjects( 2, Events, WaitAny, TRUE, NULL ); if ( Status == POS_STOP ) { Status = NtClose( NB ); InterlockedExchangePointer( (PVOID *) &NB, NULL ); NbPrintf( ("[NETAPI32] Stop event signaled, Status : %lx\n", Status) ); } else if ( ( Status == POS_RESET ) && (NB != NULL ) ) { NbPrintf( ("[NETAPI32] Reset event signaled\n") ); ResetLanaAndPostListen(); } #else Status = NtWaitForSingleObject( StopEvent, TRUE, NULL ); if ( Status == STATUS_SUCCESS ) { NbPrintf( ("[NETAPI32] Stop event signaled\n") ); NtClose( NB ); InterlockedExchangePointer( (PVOID *) &NB, NULL ); } #endif } return 0; } #if _MSC_FULL_VER >= 13008827 #pragma warning(pop) #endif VOID SendNcbToDriver( IN PNCBI pncb ) /*++ Routine Description: This routine determines the Device Ioctl code to be used to send the ncb to \Device\Netbios and then does the call to send the request to the driver. Arguments: IN PNCBI pncb - supplies the NCB to be sent to the driver. Return Value: None. --*/ { NTSTATUS ntstatus; char * buffer; unsigned short length; // Use NULL for the buffer if only the NCB is to be passed. switch ( pncb->ncb_command & ~ASYNCH ) { case NCBSEND: case NCBSENDNA: case NCBRECV: case NCBRECVANY: case NCBDGSEND: case NCBDGRECV: case NCBDGSENDBC: case NCBDGRECVBC: case NCBASTAT: case NCBFINDNAME: case NCBSSTAT: case NCBENUM: case NCBACTION: buffer = pncb->ncb_buffer; length = pncb->ncb_length; break; case NCBCANCEL: // The second buffer points to the NCB to be cancelled. buffer = pncb->ncb_buffer; length = sizeof(NCB); NbPrintf(( "[NETAPI32] Attempting to cancel PNCB: %lx\n", buffer )); DisplayNcb( (PNCBI)buffer ); break; case NCBCHAINSEND: case NCBCHAINSENDNA: { PUCHAR BigBuffer; // Points to the start of BigBuffer, not // the start of user data. PUCHAR FirstBuffer; // // There is nowhere in the NCB to save the address of BigBuffer. // The address is needed to free BigBuffer when the transfer is // complete. At the start of BigBuffer, 4 bytes are used to store // the user supplied ncb_buffer value which is restored later. // BigBuffer = RtlAllocateHeap( RtlProcessHeap(), 0, sizeof(pncb->ncb_buffer) + pncb->ncb_length + pncb->cu.ncb_chain.ncb_length2); if ( BigBuffer == NULL ) { NbPrintf(( "[NETAPI32] The Netbios BigBuffer Allocation failed: %lx\n", pncb->ncb_length + pncb->cu.ncb_chain.ncb_length2)); pncb->ncb_retcode = NRC_NORES; pncb->ncb_cmd_cplt = NRC_NORES; pncb->u.ncb_iosb.Status = STATUS_SUCCESS; PostRoutineCaller( pncb, &pncb->u.ncb_iosb, 0); return; } NbPrintf(( "[NETAPI32] BigBuffer Allocation: %lx\n", BigBuffer)); // Save users buffer address. RtlMoveMemory( BigBuffer, &pncb->ncb_buffer, sizeof(pncb->ncb_buffer)); FirstBuffer = pncb->ncb_buffer; pncb->ncb_buffer = BigBuffer; // Copy the user data. try { RtlMoveMemory( sizeof(pncb->ncb_buffer) + BigBuffer, &FirstBuffer[0], pncb->ncb_length); RtlMoveMemory( sizeof(pncb->ncb_buffer) + BigBuffer + pncb->ncb_length, &pncb->cu.ncb_chain.ncb_buffer2[0], pncb->cu.ncb_chain.ncb_length2); } except (EXCEPTION_EXECUTE_HANDLER) { pncb->ncb_retcode = NRC_BUFLEN; pncb->ncb_cmd_cplt = NRC_BUFLEN; pncb->u.ncb_iosb.Status = STATUS_SUCCESS; ChainSendPostRoutine( pncb, &pncb->u.ncb_iosb, 0); return; } NbPrintf(( "[NETAPI32] Submit chain send pncb: %lx, event: %lx, post: %lx. \n", pncb, pncb->ncb_event, pncb->ncb_post)); ntstatus = NtDeviceIoControlFile( NB, NULL, ChainSendPostRoutine, // APC Routine pncb, // APC Context &pncb->u.ncb_iosb, // IO Status block IOCTL_NB_NCB, pncb, // InputBuffer sizeof(NCB), sizeof(pncb->ncb_buffer) + BigBuffer, // Outputbuffer pncb->ncb_length + pncb->cu.ncb_chain.ncb_length2); if ((ntstatus != STATUS_SUCCESS) && (ntstatus != STATUS_PENDING) && (ntstatus != STATUS_HANGUP_REQUIRED)) { NbPrintf(( "[NETAPI32] The Netbios Chain Send failed: %X\n", ntstatus )); if ( ntstatus == STATUS_ACCESS_VIOLATION ) { pncb->ncb_retcode = NRC_BUFLEN; } else { pncb->ncb_retcode = NRC_SYSTEM; } ChainSendPostRoutine( pncb, &pncb->u.ncb_iosb, 0); } NbPrintf(( "[NETAPI32] PNCB: %lx completed, status:%lx, ncb_retcode: %#04x\n", pncb, ntstatus, pncb->ncb_retcode )); return; } #if AUTO_RESET // // added to fix bug : 170107 // // // Remember the parameters used in reseting a LANA. LANAs need to // be automatically re-reset when they get unbound and bound back to // netbios.sys. This happens in the case of TCPIP devices that renew // their IP addresses. // case NCBRESET : { PRESET_LANA_NCB prlnTmp; PLIST_ENTRY ple, pleHead; buffer = NULL; length = 0; NbPrintf( ( "[NETAPI32] : Netbios : reseting adapter %d\n", pncb-> ncb_lana_num ) ); // // Add Reset NCB to global list // EnterCriticalSection( &ResetCS ); // // check if already present // pleHead = &LanaResetList; for ( ple = pleHead-> Flink; ple != pleHead; ple = ple-> Flink ) { prlnTmp = CONTAINING_RECORD( ple, RESET_LANA_NCB, leList ); if ( prlnTmp-> ResetNCB.ncb_lana_num == pncb-> ncb_lana_num ) { break; } } if ( ple == pleHead ) { // // NO reset was performed before for this LANA // // // allocate a NCB entry and copy the NCB used // prlnTmp = HeapAlloc( GetProcessHeap(), 0, sizeof( RESET_LANA_NCB ) ); if ( prlnTmp == NULL ) { NbPrintf( ( "[NETAPI32] : Netbios : Failed to allocate RESET_LANA_NCB" ) ); LeaveCriticalSection( &ResetCS ); break; } ZeroMemory( prlnTmp, sizeof( RESET_LANA_NCB ) ); InitializeListHead( &prlnTmp-> leList ); CopyMemory( &prlnTmp-> ResetNCB, pncb, FIELD_OFFSET( NCB, ncb_cmd_cplt ) ); InsertTailList( &LanaResetList, &prlnTmp-> leList ); } else { // // Lana was previously reset. Overwrite old parameters. // CopyMemory( &prlnTmp-> ResetNCB, pncb, FIELD_OFFSET( NCB, ncb_cmd_cplt ) ); } // // clear out event/post completion routine when saving the ResetNCB. // When this NCB is used to re-issue the reset command, there is no // post completion processing to be done. // prlnTmp-> ResetNCB.ncb_event = NULL; prlnTmp-> ResetNCB.ncb_post = NULL; // // when a reset is re-issued it will always a ASYNC command. // prlnTmp-> ResetNCB.ncb_command = pncb-> ncb_command | ASYNCH; LeaveCriticalSection( &ResetCS ); break; } #endif default: buffer = NULL; length = 0; break; } // NbPrintf(( "[NETAPI32] Submit pncb: %lx, event: %lx, post: %lx. \n", // pncb, // pncb->ncb_event, // pncb->ncb_post)); ntstatus = NtDeviceIoControlFile( NB, NULL, PostRoutineCaller, // APC Routine pncb, // APC Context &pncb->u.ncb_iosb, // IO Status block IOCTL_NB_NCB, pncb, // InputBuffer sizeof(NCB), buffer, // Outputbuffer length ); if ((ntstatus != STATUS_SUCCESS) && (ntstatus != STATUS_PENDING) && (ntstatus != STATUS_HANGUP_REQUIRED)) { NbPrintf(( "[NETAPI32] The Netbios NtDeviceIoControlFile failed: %X\n", ntstatus )); NbPrintf(( "[NETAPI32] PNCB: %lx completed, status:%lx, ncb_retcode: %#04x," "ncb_cmd_cmplt: %#04x\n", pncb, ntstatus, pncb->ncb_retcode, pncb-> ncb_cmd_cplt )); if ( ntstatus == STATUS_ACCESS_VIOLATION ) { pncb->ncb_retcode = NRC_BUFLEN; } else { pncb->ncb_retcode = NRC_SYSTEM; } PostRoutineCaller( pncb, &pncb->u.ncb_iosb, 0); } return; } VOID SpinUpAddnameThread( IN PNCBI pncb ) /*++ Routine Description: Spin up an another thread so that the worker thread does not block while the blocking fsctl is being processed. Arguments: IN PNCBI pncb - supplies the NCB to be sent to the driver. Return Value: None. --*/ { HANDLE Threadid; HANDLE AddNameHandle; EnterCriticalSection( &Crit ); AddNameThreadCount++; NtResetEvent( AddNameEvent, NULL ); LeaveCriticalSection( &Crit ); AddNameHandle = CreateThread( NULL, // Standard thread attributes 0, // Use same size stack as users // application SendAddNcbToDriver, // Routine to start in new thread pncb, // Parameter to thread 0, // No special CreateFlags (LPDWORD)&Threadid); if ( AddNameHandle == NULL ) { // // Wait a couple of seconds just in case this is a burst // of addnames and we have run out of resources creating // threads. In a couple of seconds one of the other // addname threads should complete. // Sleep(2000); AddNameHandle = CreateThread( NULL, // Standard thread attributes 0, // Use same size stack as users // application SendAddNcbToDriver, // Routine to start in new thread pncb, // Parameter to thread 0, // No special CreateFlags (LPDWORD)&Threadid); if ( AddNameHandle == NULL ) { // // Retry failed. Lower the counts to their values prior to // calling SpinUpAddNameThread // AddNameThreadExit(); pncb->ncb_retcode = NRC_NORES; NbPrintf(( "[NETAPI32] Create Addname Worker Thread failed\n" )); pncb->u.ncb_iosb.Status = STATUS_SUCCESS; PostRoutineCaller( pncb, &pncb->u.ncb_iosb, 0); } else { CloseHandle( AddNameHandle ); } } else { CloseHandle( AddNameHandle ); } } VOID AddNameThreadExit( VOID ) /*++ Routine Description: Keep counts accurate so that any resets being processed by the main worker thread block appropriately. Arguments: none. Return Value: none. --*/ { EnterCriticalSection( &Crit ); AddNameThreadCount--; if (AddNameThreadCount == 0) { NtSetEvent(AddNameEvent, NULL); } LeaveCriticalSection( &Crit ); } DWORD SendAddNcbToDriver( IN PVOID Context ) /*++ Routine Description: This routine is used to post an addname or adapter status ensuring that the worker thread does not block. Arguments: IN PVOID Context - supplies the NCB to be sent to the driver. Return Value: None. --*/ { PNCBI pncb = (PNCBI) Context; void (CALLBACK *post)( struct _NCB * ); HANDLE event; HANDLE LocalEvent; UCHAR command; NTSTATUS ntstatus; char * buffer; unsigned short length; try { command = pncb->ncb_command; post = pncb->ncb_post; event = pncb->ncb_event; ntstatus = NtCreateEvent( &LocalEvent, EVENT_ALL_ACCESS, NULL, SynchronizationEvent, FALSE ); if ( !NT_SUCCESS(ntstatus) ) { pncb->ncb_retcode = NRC_NORES; NbPrintf(( "[NETAPI32] Could not create event\n" )); pncb->u.ncb_iosb.Status = STATUS_SUCCESS; PostRoutineCaller( pncb, &pncb->u.ncb_iosb, 0); AddNameThreadExit(); return 0; } // // While the NCB is submitted the driver can modify the contents // of the NCB. We will ensure that this thread waits until the addname // completes before it exits. // pncb->ncb_command = pncb->ncb_command & ~ASYNCH; if ( pncb->ncb_command == NCBASTAT ) { buffer = pncb->ncb_buffer; length = pncb->ncb_length; } else { ASSERT( (pncb->ncb_command == NCBADDNAME) || (pncb->ncb_command == NCBADDGRNAME) || (pncb->ncb_command == NCBASTAT) ); buffer = NULL; length = 0; } ntstatus = NtDeviceIoControlFile( NB, LocalEvent, NULL, // APC Routine NULL, // APC Context &pncb->u.ncb_iosb, // IO Status block IOCTL_NB_NCB, pncb, // InputBuffer sizeof(NCB), buffer, // Outputbuffer length ); if ((ntstatus != STATUS_SUCCESS) && (ntstatus != STATUS_PENDING) && (ntstatus != STATUS_HANGUP_REQUIRED)) { NbPrintf(( "[NETAPI32] The Netbios NtDeviceIoControlFile failed: %X\n", ntstatus )); if ( ntstatus == STATUS_ACCESS_VIOLATION ) { pncb->ncb_retcode = NRC_BUFLEN; } else { pncb->ncb_retcode = NRC_SYSTEM; } } else { do { ntstatus = NtWaitForSingleObject( LocalEvent, TRUE, NULL ); } while ( (ntstatus == STATUS_USER_APC) || (ntstatus == STATUS_ALERTED) ); ASSERT(ntstatus == STATUS_SUCCESS); } pncb->ncb_command = command; // Set the flag that indicates that the NCB is now completed. pncb->ncb_cmd_cplt = pncb->ncb_retcode; // Allow application/worker thread to proceed. if ( event != NULL ) { NtSetEvent( event, NULL ); } // If the user supplied a post routine then call it. if (( post != NULL ) && ( (command & ASYNCH) != 0 )) { (*(post))( (PNCB)pncb ); } } except (EXCEPTION_EXECUTE_HANDLER) { NbPrintf(( "[NETAPI32] Netbios: Access Violation post processing NCB %lx\n", pncb )); NbPrintf(( "[NETAPI32] Netbios: Probable application error\n" )); } NtClose( LocalEvent ); AddNameThreadExit(); ExitThread(0); return 0; } VOID PostRoutineCaller( PVOID Context, PIO_STATUS_BLOCK Status, ULONG Reserved ) /*++ Routine Description: This routine is supplied by SendNcbToDriver to the Io system when a Post routine is to be called directly. Arguments: IN PVOID Context - supplies the NCB post routine to be called. IN PIO_STATUS_BLOCK Status. IN ULONG Reserved. Return Value: none. --*/ { PNCBI pncbi = (PNCBI) Context; void (CALLBACK *post)( struct _NCB * ); HANDLE event; UCHAR command; try { if ( Status->Status == STATUS_HANGUP_REQUIRED ) { HangupConnection( pncbi ); } // // Save the command, post routine and the handle to the event so that if the other thread is // polling the cmd_cplt flag or the event awaiting completion and immediately trashes // the NCB, we behave appropriately. // post = pncbi->ncb_post; event = pncbi->ncb_event; command = pncbi->ncb_command; // Set the flag that indicates that the NCB is now completed. pncbi->ncb_cmd_cplt = pncbi->ncb_retcode; // // NCB may be queued again // EnterCriticalSection( &Crit ); pncbi->ncb_reserved = 0; LeaveCriticalSection( &Crit ); // Allow application/worker thread to proceed. if ( event != NULL ) { NtSetEvent( event, NULL ); } // If the user supplied a post routine then call it. if (( post != NULL ) && ( (command & ASYNCH) != 0 )) { (*(post))( (PNCB)pncbi ); } } except (EXCEPTION_EXECUTE_HANDLER) { NbPrintf(( "[NETAPI32] Netbios: Access Violation post processing NCB %lx\n", pncbi )); NbPrintf(( "[NETAPI32] Netbios: Probable application error\n" )); } UNREFERENCED_PARAMETER( Reserved ); } VOID ChainSendPostRoutine( PVOID Context, PIO_STATUS_BLOCK Status, ULONG Reserved ) /*++ Routine Description: This routine is supplied by SendNcbToDriver to the Io system when a chain send ncb is being processed. When the send is complete, this routine deletes the BigBuffer used to hold the two parts of the chain send. It then calls a post routine if the user supplied one. Arguments: IN PVOID Context - supplies the NCB post routine to be called. IN PIO_STATUS_BLOCK Status. IN ULONG Reserved. Return Value: none. --*/ { PNCBI pncbi = (PNCBI) Context; PUCHAR BigBuffer; void (CALLBACK *post)( struct _NCB * ); HANDLE event; UCHAR command; BigBuffer = pncbi->ncb_buffer; try { // Restore the users NCB contents. RtlMoveMemory( &pncbi->ncb_buffer, BigBuffer, sizeof(pncbi->ncb_buffer)); NbPrintf(( "[NETAPI32] ChainSendPostRoutine PNCB: %lx, Status: %X\n", pncbi, Status->Status )); DisplayNcb( pncbi ); if ( Status->Status == STATUS_HANGUP_REQUIRED ) { HangupConnection( pncbi ); } // // Save the command, post routine and the handle to the event so that if the other thread is // polling the cmd_cplt flag or the event awaiting completion and immediately trashes // the NCB, we behave appropriately. // post = pncbi->ncb_post; event = pncbi->ncb_event; command = pncbi->ncb_command; // Set the flag that indicates that the NCB is now completed. pncbi->ncb_cmd_cplt = pncbi->ncb_retcode; // // NCB may be queued again // EnterCriticalSection( &Crit ); pncbi->ncb_reserved = 0; LeaveCriticalSection( &Crit ); // Allow application/worker thread to proceed. if ( event != NULL ) { NtSetEvent(event, NULL); } // If the user supplied a post routine then call it. if (( post != NULL ) && ( (command & ASYNCH) != 0 )) { (*(post))( (PNCB)pncbi ); } } except (EXCEPTION_EXECUTE_HANDLER) { NbPrintf(( "[NETAPI32] Netbios: Access Violation post processing NCB %lx\n", pncbi )); NbPrintf(( "[NETAPI32] Netbios: Probable application error\n" )); } RtlFreeHeap( RtlProcessHeap(), 0, BigBuffer); UNREFERENCED_PARAMETER( Reserved ); } VOID HangupConnection( PNCBI pUserNcb ) /*++ Routine Description: This routine generates a hangup for the connection. This allows orderly cleanup of the connection block in the driver. The return value from the hangup is not used. If the hangup overlaps with a reset or a hangup then the hangup will have no effect. The user application is unaware that this operation is being performed. Arguments: IN PNCBI pUserNcb - Identifies the connection to be hung up. Return Value: none. --*/ { NCBI ncbi; NTSTATUS Status; RtlZeroMemory( &ncbi, sizeof (NCB) ); ncbi.ncb_command = NCBHANGUP; ncbi.ncb_lsn = pUserNcb->ncb_lsn; ncbi.ncb_lana_num = pUserNcb->ncb_lana_num; ncbi.ncb_retcode = ncbi.ncb_cmd_cplt = NRC_PENDING; Status = NtCreateEvent( &ncbi.ncb_event, EVENT_ALL_ACCESS, NULL, SynchronizationEvent, FALSE ); if ( !NT_SUCCESS(Status) ) { // // Failed to create event. Cleanup of the Cb will have to wait until // the user decides to do another request or exits. // NbPrintf(( "[NETAPI32] Hangup Session PNCBI: %lx failed to create event!\n" )); return; } Status = NtDeviceIoControlFile( NB, ncbi.ncb_event, NULL, // APC Routine NULL, // APC Context &ncbi.u.ncb_iosb, // IO Status block IOCTL_NB_NCB, &ncbi, // InputBuffer sizeof(NCB), NULL, // Outputbuffer 0 ); // // We must always wait to allow the Apc to fire // do { Status = NtWaitForSingleObject( ncbi.ncb_event, TRUE, NULL ); } while ( (Status == STATUS_USER_APC) || (Status == STATUS_ALERTED) ); ASSERT(Status == STATUS_SUCCESS); if (! NT_SUCCESS(Status)) { NbPrintf(( "[NETAPI32] The Netbios NtWaitForSingleObject failed: %X\n", Status )); } NtClose( ncbi.ncb_event ); } VOID NetbiosInitialize( HMODULE hModule ) /*++ Routine Description: This routine is called each time a process that uses netapi.dll starts up. Arguments: IN HMODULE hModule - Handle to module instance (netapi32.dll) Return Value: none. --*/ { Initialized = FALSE; WorkerHandle = NULL; InitializeCriticalSection( &Crit ); #if AUTO_RESET InitializeCriticalSection( &ResetCS ); InitializeListHead( &LanaResetList ); RtlZeroMemory( &OutputNCB, sizeof( NCB ) ); #endif g_hModule = hModule; } VOID NetbiosDelete( VOID ) /*++ Routine Description: This routine is called each time a process that uses netapi.dll Exits. It resets all lana numbers that could have been used by this process. This will cause all Irp's in the system to be completed because all the Connection and Address handles will be closed tidily. Arguments: none. Return Value: none. --*/ { #if AUTO_RESET PLIST_ENTRY ple; PRESET_LANA_NCB prln; while ( !IsListEmpty( &LanaResetList ) ) { ple = RemoveHeadList( &LanaResetList ); prln = CONTAINING_RECORD( ple, RESET_LANA_NCB, leList ); HeapFree( GetProcessHeap(), 0, prln ); } DeleteCriticalSection( &ResetCS ); #endif DeleteCriticalSection( &Crit ); if ( Initialized == FALSE ) { // This process did not use Netbios. return; } NtClose(NB); } #if AUTO_RESET VOID ResetLanaAndPostListen( ) /*++ Routine Description: This routine is invoked in response to new LANA being indicated to NETBIOS.SYS. When this occurs the IOCTL posted by this user-mode component of netbios (to listen for new LANA indications) is completed. In response the new LANA is reset if it had previously been reset. In addition the routine re-posts the listen to the kernel mode component of netbios (NETBIOS.SYS). An exception to this is if the LANA number to be reset is 255 ( MAX_LANA + 1 ). This is a special case that indicates the NETBIOS.SYS is stopping and listen should not be reposted in this case. Arguments: none. Return Value: none. --*/ { NTSTATUS Status; PRESET_LANA_NCB prln; PLIST_ENTRY ple, pleHead; NbPrintf( ("[NETAPI32] : Netbios : Entered ResetLanaAndPostListen \n") ); // // Check if the LANA number is valid. // if ( OutputNCB.ncb_lana_num != ( MAX_LANA + 1 ) ) { EnterCriticalSection( &ResetCS ); // // find which lana needs a reset // NbPrintf( ( "[NETAPI32] : Netbios : Looking for Lana %d\n", OutputNCB.ncb_lana_num ) ); pleHead = &LanaResetList; for ( ple = pleHead-> Flink; ple != pleHead; ple = ple-> Flink ) { prln = CONTAINING_RECORD( ple, RESET_LANA_NCB, leList ); if ( prln-> ResetNCB.ncb_lana_num == OutputNCB.ncb_lana_num ) { // // found Lana that needs reseting // break; } } // // if found send reset // if ( ple != pleHead ) { // // Send Reset to NETBIOS.SYS // QueueToWorker( (PNCBI) &prln-> ResetNCB ); } else { NbPrintf( ( "[NETAPI32] : Netbios : Lana %d not found\n", OutputNCB.ncb_lana_num ) ); } LeaveCriticalSection( &ResetCS ); OutputNCB.ncb_lana_num = 0; // // post listen again // Status = NtDeviceIoControlFile( NB, LanaResetEvent, NULL, NULL, &ResetStatusBlock, IOCTL_NB_REGISTER_RESET, NULL, 0, (PVOID) &OutputNCB, sizeof( NCB ) ); if ( ( Status != STATUS_PENDING ) && ( Status != STATUS_SUCCESS ) ) { // // Failed to register reset notification. // NbPrintf( ("[NETAPI32] : Netbios : Failed to register Reset event\n" ) ); } } else { NbPrintf( ( "[NETAPI32] : Netbios : LANA 255 indicated, no Listen posted\n" ) ) } NbPrintf( ("[NETAPI32] : Netbios : Leaving ResetLanaAndPostListen \n") ); } #endif