/*++ Copyright (c) 1990-1994 Microsoft Corporation All rights reserved Module Name: SplInit.c Abstract: Initialize the spooler. Author: Environment: User Mode -Win32 Revision History: 4-Jan-1999 Khaleds Added Code for optimiziting the load time of the spooler by decoupling the startup dependency between spoolsv and spoolss --*/ #include "precomp.h" #pragma hdrstop #include "local.h" LPWSTR szDevice = L"Device"; LPWSTR szPrinters = L"Printers"; LPWSTR szDeviceOld = L"DeviceOld"; LPWSTR szNULL = L""; LPWSTR szPorts=L"Ports"; LPWSTR szWinspool = L"winspool"; LPWSTR szNetwork = L"Ne"; LPWSTR szTimeouts = L",15,45"; LPWSTR szDotDefault = L".Default"; LPWSTR szRegDevicesPath = L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Devices"; LPWSTR szRegWindowsPath = L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Windows"; LPWSTR szRegPrinterPortsPath = L"Software\\Microsoft\\Windows NT\\CurrentVersion\\PrinterPorts"; LPWSTR szCurrentVersionPath = L"Software\\Microsoft\\Windows NT\\CurrentVersion"; LPWSTR szDevModes2Path = L"Printers\\DevModes2"; PrintSpoolerServerExports *gpServerExports = NULL; typedef struct INIT_REG_USER { HKEY hKeyUser; HKEY hKeyWindows; HKEY hKeyDevices; HKEY hKeyPrinterPorts; BOOL bFoundPrinter; BOOL bDefaultSearch; BOOL bDefaultFound; BOOL bFirstPrinterFound; DWORD dwNetCounter; WCHAR szFirstPrinter[MAX_PATH * 2]; WCHAR szDefaultPrinter[MAX_PATH * 2]; } INIT_REG_USER, *PINIT_REG_USER; // // Prototypes // BOOL SplRegCopy( PINIT_REG_USER pUser, HKEY hMcConnectionKey ); BOOL InitializeRegUser( LPWSTR szSubKey, PINIT_REG_USER pUser ); VOID FreeRegUser( PINIT_REG_USER pUser ); BOOL SetupRegForUsers( PINIT_REG_USER pUsers, DWORD cUsers ); VOID UpdateUsersDefaultPrinter( IN PINIT_REG_USER pUser, IN BOOL bFindDefault ); HRESULT IsUsersDefaultPrinter( IN PINIT_REG_USER pUser, IN PCWSTR pszPrinterName ); DWORD ReadPrinters( PINIT_REG_USER pUser, DWORD Flags, PDWORD pcbPrinters, LPBYTE* ppPrinters ); BOOL UpdatePrinterInfo( const PINIT_REG_USER pCurUser, LPCWSTR pPrinterName, LPCWSTR pPorts, PDWORD pdwNetId ); BOOL EnumerateConnectedPrinters( LPBYTE pPrinter, DWORD cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned, HKEY hKeyUser ); VOID RegClearKey( HKEY hKey ); LPWSTR CheckBadPortName( LPWSTR pszPort ); BOOL UpdateLogonTimeStamp( void ); BOOL SpoolerInitAll( VOID ) { DWORD dwError; WCHAR szClass[MAX_PATH]; WCHAR szSubKey[MAX_PATH]; DWORD cUsers; DWORD cSubKeys; DWORD cchMaxSubkey; DWORD cchMaxClass; DWORD cValues; DWORD cbMaxValueData; DWORD cbSecurityDescriptor; DWORD cchClass; DWORD cchMaxValueName; FILETIME ftLastWriteTime; BOOL bSuccess; DWORD cchSubKey; PINIT_REG_USER pUsers; PINIT_REG_USER pCurUser; DWORD i; cchClass = COUNTOF(szClass); dwError = RegQueryInfoKey(HKEY_USERS, szClass, &cchClass, NULL, &cSubKeys, &cchMaxSubkey, &cchMaxClass, &cValues, &cchMaxValueName, &cbMaxValueData, &cbSecurityDescriptor, &ftLastWriteTime); if (dwError) { SetLastError( dwError ); DBGMSG(DBG_WARNING, ("SpoolerIniAll failed RegQueryInfoKey HKEY_USERS error %d\n", dwError)); return FALSE; } if (cSubKeys < 1) return TRUE; pUsers = AllocSplMem(cSubKeys * sizeof(pUsers[0])); if (!pUsers) { DBGMSG(DBG_WARNING, ("SpoolerIniAll failed to allocate pUsers error %d\n", dwError)); return FALSE; } for (i=0, pCurUser=pUsers, cUsers=0; i< cSubKeys; i++) { cchSubKey = COUNTOF(szSubKey); dwError = RegEnumKeyEx(HKEY_USERS, i, szSubKey, &cchSubKey, NULL, NULL, NULL, &ftLastWriteTime); if ( dwError ) { // // We possibly should return an error here if we fail to initiatise a // user. // DBGMSG( DBG_WARNING, ("SpoolerInitAll failed RegEnumKeyEx HKEY_USERS %ws %d %d\n", szSubKey, i, dwError)); SetLastError( dwError ); } else { if (!_wcsicmp(szSubKey, szDotDefault) || wcschr(szSubKey, L'_')) { continue; } if (InitializeRegUser(szSubKey, pCurUser)) { pCurUser++; cUsers++; } } } bSuccess = SetupRegForUsers(pUsers, cUsers); for (i=0; i< cUsers; i++) FreeRegUser(&pUsers[i]); // // In case we are starting after the user has logged in, inform // all applications that there may be printers now. // BroadcastMessage(BROADCAST_TYPE_CHANGEDEFAULT, 0, 0, 0); FreeSplMem(pUsers); if ( !bSuccess ) { DBGMSG( DBG_WARNING, ("SpoolerInitAll failed error %d\n", GetLastError() )); } else { DBGMSG( DBG_TRACE, ("SpoolerInitAll Success\n" )); } return bSuccess; } BOOL DeleteOldPerMcConnections( HKEY hConnectionKey, HKEY hMcConnectionKey ) /*++ Function Description - Deletes the existing permachine connections from hConnectionKey Parameters - hConnectionKey - handle to hUserKey\Printers\Connections Return Values - TRUE if success FALSE otherwise. --*/ { BOOL bReturn = TRUE; struct Node { struct Node *pNext; LPTSTR szPrinterName; } *phead = NULL,*ptemp = NULL; LONG lstatus; DWORD dwRegIndex,dwNameSize,cbdata,dwquerylocal,dwType; WCHAR szPrinterName[MAX_UNC_PRINTER_NAME]; HKEY hPrinterKey; // Before deleting the old permachine connections, we need to record all them into // a list. This is required because, the subkeys should not be deleted while they // are being enumerated. // Identifying permachine connections and saving the printernames in a list. for (dwRegIndex = 0; dwNameSize = COUNTOF(szPrinterName), ((lstatus = RegEnumKeyEx(hConnectionKey, dwRegIndex, szPrinterName, &dwNameSize, NULL, NULL, NULL, NULL)) == ERROR_SUCCESS); ++dwRegIndex) { if (RegOpenKeyEx(hConnectionKey, szPrinterName, 0, KEY_READ, &hPrinterKey) != ERROR_SUCCESS) { bReturn = FALSE; goto CleanUp; } dwquerylocal = 0; cbdata = sizeof(dwquerylocal); RegQueryValueEx(hPrinterKey, L"LocalConnection", NULL, &dwType, (LPBYTE)&dwquerylocal, &cbdata); RegCloseKey(hPrinterKey); // // See if it's a LocalConnection, and if it exists on the current // machine. We don't want to delete it if it is a per-machine // connection, since we want to keep the associated per-user // DevMode. // if( ERROR_SUCCESS == RegOpenKeyEx( hMcConnectionKey, szPrinterName, 0, KEY_READ, &hPrinterKey )) { // // The per-machine key exists. Close it and don't bother // deleting this connection. // RegCloseKey( hPrinterKey ); } else { // // It's not a per-machine connection. Prepare to delete it. // if (dwquerylocal == 1) { if (!(ptemp = (struct Node *) AllocSplMem(sizeof(struct Node)))) { bReturn = FALSE; goto CleanUp; } ptemp->pNext = phead; phead = ptemp; if (!(ptemp->szPrinterName = AllocSplStr(szPrinterName))) { bReturn = FALSE; goto CleanUp; } } } } if (lstatus != ERROR_NO_MORE_ITEMS) { bReturn = FALSE; goto CleanUp; } // Deleting old permachine connections. The printer names are stored in the // list pointed to by phead. for (ptemp = phead; ptemp != NULL; ptemp = ptemp->pNext) { if (RegDeleteKey(hConnectionKey,ptemp->szPrinterName) != ERROR_SUCCESS) { bReturn = FALSE; goto CleanUp; } } CleanUp: while (ptemp = phead) { phead = phead->pNext; if (ptemp->szPrinterName) FreeSplStr(ptemp->szPrinterName); FreeSplMem(ptemp); } return bReturn; } BOOL AddNewPerMcConnections( HKEY hConnectionKey, HKEY hMcConnectionKey ) /*++ Function Description - Adds per-machine connections to the user hive if the connection does not already exist. Parameters - hConnectionKey - handle to hUserKey\Printers\Connections hMcConnectionKey - handle to HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\ Control\Print\Connections Return Values - TRUE if success FALSE otherwise. --*/ { DWORD dwRegIndex,dwNameSize,cbdata,dwType,dwlocalconnection = 1; WCHAR szPrinterName[MAX_UNC_PRINTER_NAME]; WCHAR szConnData[MAX_UNC_PRINTER_NAME]; LONG lstatus; BOOL bReturn = TRUE; HKEY hNewConnKey = NULL, hPrinterKey = NULL; for (dwRegIndex = 0; dwNameSize = COUNTOF(szPrinterName), ((lstatus = RegEnumKeyEx(hMcConnectionKey, dwRegIndex, szPrinterName, &dwNameSize, NULL, NULL, NULL, NULL)) == ERROR_SUCCESS); ++dwRegIndex) { RegOpenKeyEx(hConnectionKey,szPrinterName,0,KEY_READ,&hNewConnKey); if (hNewConnKey == NULL) { // Connection does not exist. Add one. if (RegCreateKeyEx(hConnectionKey, szPrinterName, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hNewConnKey, NULL) || RegOpenKeyEx(hMcConnectionKey, szPrinterName, 0, KEY_READ, &hPrinterKey)) { bReturn = FALSE; goto CleanUp; } cbdata = sizeof(szConnData); if (RegQueryValueEx(hPrinterKey,L"Server",NULL,&dwType,(LPBYTE)szConnData,&cbdata) || RegSetValueEx(hNewConnKey,L"Server",0,dwType,(LPBYTE)szConnData,cbdata)) { bReturn = FALSE; goto CleanUp; } cbdata = sizeof(szConnData); if (RegQueryValueEx(hPrinterKey,L"Provider",NULL,&dwType,(LPBYTE)szConnData,&cbdata) || RegSetValueEx(hNewConnKey,L"Provider",0,dwType,(LPBYTE)szConnData,cbdata) || RegSetValueEx(hNewConnKey,L"LocalConnection",0,REG_DWORD, (LPBYTE)&dwlocalconnection,sizeof(dwlocalconnection))) { bReturn = FALSE; goto CleanUp; } RegCloseKey(hPrinterKey); hPrinterKey = NULL; } RegCloseKey(hNewConnKey); hNewConnKey = NULL; } if (lstatus != ERROR_NO_MORE_ITEMS) { bReturn = FALSE; } CleanUp: if (hNewConnKey) { RegCloseKey(hNewConnKey); } if (hPrinterKey) { RegCloseKey(hPrinterKey); } return bReturn; } BOOL SplRegCopy( PINIT_REG_USER pUser, HKEY hMcConnectionKey) /*++ Function Description - Removes old permachine connections for pUser and adds the new permachine connections from hMcConnectionKey Parameters - pUser - pointer to INIT_REG_USER which contains hUserKey. hMcConnectionKey - handle to HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\ Control\Print\Connections Return Values - TRUE if success FALSE otherwise. --*/ { LONG lstatus; BOOL bReturn = TRUE; WCHAR szRegistryConnections[] = L"Printers\\Connections"; HKEY hConnectionKey = NULL; // Create (if not already present) and open Connections subkey lstatus = RegCreateKeyEx(pUser->hKeyUser, szRegistryConnections, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hConnectionKey, NULL); if (lstatus != ERROR_SUCCESS) { bReturn = FALSE; goto CleanUp; } if (!DeleteOldPerMcConnections(hConnectionKey,hMcConnectionKey) || !AddNewPerMcConnections(hConnectionKey,hMcConnectionKey)) { bReturn = FALSE; } CleanUp: if (hConnectionKey) { RegCloseKey(hConnectionKey); } return bReturn; } BOOL SetupRegForUsers( PINIT_REG_USER pUsers, DWORD cUsers) { DWORD cbPrinters; DWORD cPrinters; PBYTE pPrinters; HKEY hMcConnectionKey = NULL; WCHAR szMachineConnections[] = L"SYSTEM\\CurrentControlSet\\Control\\Print\\Connections"; #define pPrinters2 ((PPRINTER_INFO_2)pPrinters) #define pPrinters4 ((PPRINTER_INFO_4)pPrinters) DWORD i, j; LPWSTR pszPort; // // Read in local printers. // cbPrinters = 1000; pPrinters = AllocSplMem(cbPrinters); if (!pPrinters) return FALSE; if (cPrinters = ReadPrinters(NULL, PRINTER_ENUM_LOCAL, &cbPrinters, &pPrinters)) { for (i=0; i< cUsers; i++) { for(j=0; j< cPrinters; j++) { if( pPrinters2[j].Attributes & PRINTER_ATTRIBUTE_NETWORK ){ // // Use NeXX: // pszPort = NULL; } else { pszPort = CheckBadPortName( pPrinters2[j].pPortName ); } UpdatePrinterInfo( &pUsers[i], pPrinters2[j].pPrinterName, pszPort, &(pUsers[i].dwNetCounter)); } } } // Open the Key containing the current list of per-machine connections. RegOpenKeyEx(HKEY_LOCAL_MACHINE, szMachineConnections, 0, KEY_READ , &hMcConnectionKey); for (i=0; i< cUsers; i++) { // Copy Per Machine Connections into the user hive SplRegCopy(&pUsers[i], hMcConnectionKey); if (cPrinters = ReadPrinters(&pUsers[i], PRINTER_ENUM_CONNECTIONS, &cbPrinters, &pPrinters)) { for(j=0; j< cPrinters; j++) { UpdatePrinterInfo(&pUsers[i], pPrinters4[j].pPrinterName, NULL, &(pUsers[i].dwNetCounter)); } } } // Close the handle to Per Machine Connections. if (hMcConnectionKey) RegCloseKey(hMcConnectionKey); FreeSplMem(pPrinters); for (i=0; i< cUsers; i++) { UpdateUsersDefaultPrinter(&pUsers[i], FALSE); } return TRUE; #undef pPrinters2 #undef pPrinters4 } VOID UpdateUsersDefaultPrinter( IN PINIT_REG_USER pUser, IN BOOL bFindDefault ) /*++ Routine Description: Updates the default printer using the information in the current users reg structure. If the bFindDefault flag is specified then a default printer is located. The method for this is first see if there is currently a default printer, then user this. If a default printer is not found then located the first printer in devices section, again if on exists. Arguments: pUser - Information about the current user, reg keys etc. This routine assumes that hKeyWindows and hKeyDevices are valid opened registry keys, with read access. bFindDefault - TRUE located a default printer, FALSE the default printer is already specified in the users reg structure. Return Value: Nothing. --*/ { LPWSTR pszNewDefault = NULL; // // If a request to find the default printer. // if (bFindDefault) { DWORD dwError = ERROR_SUCCESS; DWORD cbData = sizeof(pUser->szDefaultPrinter); // // Check if there is a default printer. // dwError = RegQueryValueEx(pUser->hKeyWindows, szDevice, NULL, NULL, (PBYTE)pUser->szDefaultPrinter, &cbData); // // If the device key was read and there is a non null string // as the default printer name. // if (dwError == ERROR_SUCCESS && pUser->szDefaultPrinter[0] != L'\0') { pUser->bDefaultFound = TRUE; } else { // // Default was not found. // pUser->bDefaultFound = FALSE; // // If a first printer was not found. // if (!pUser->bFirstPrinterFound) { DWORD cchPrinterLen = 0; WCHAR szBuffer [MAX_PATH*2]; DWORD cbDataBuffer = sizeof(szBuffer); DBGMSG(DBG_TRACE, ("UpdateUsersDefaultPrinter default printer not found.\n")); cchPrinterLen = cbData = COUNTOF(pUser->szFirstPrinter); // // Default printer was not found, find any printer // in the devices section of the registry. // dwError = RegEnumValue(pUser->hKeyDevices, 0, pUser->szFirstPrinter, &cbData, NULL, NULL, (PBYTE)szBuffer, &cbDataBuffer); if (dwError == ERROR_SUCCESS) { StringCchCat(pUser->szFirstPrinter, cchPrinterLen, L","); StringCchCat(pUser->szFirstPrinter, cchPrinterLen, szBuffer); pUser->bFirstPrinterFound = TRUE; } else { DBGMSG(DBG_WARNING, ("UpdateUsersDefaultPrinter no printer found in devices section.\n")); pUser->bFirstPrinterFound = FALSE; } } } } // // If default wasn't present, and we did get a first printer, // make this the default. // if (!pUser->bDefaultFound) { if (pUser->bFirstPrinterFound) { pszNewDefault = pUser->szFirstPrinter; } } else { // // Write out default. // pszNewDefault = pUser->szDefaultPrinter; } if (pszNewDefault) { RegSetValueEx(pUser->hKeyWindows, szDevice, 0, REG_SZ, (PBYTE)pszNewDefault, (wcslen(pszNewDefault) + 1) * sizeof(pszNewDefault[0])); } } HRESULT IsUsersDefaultPrinter( IN PINIT_REG_USER pUser, IN PCWSTR pszPrinterName ) /*++ Routine Description: Asks if the users default printer matched the specified printer name. Arguments: pCurUser - Information about the current user, reg keys etc. This routine assumes that hKeyWindows is a valid opened registry keys, with at least read access. pszPrinterName - Printer name to check if it is the default printer. Return Value: S_OK the printer name is the default, S_FALSE the printer is not the default, An HRESULT error code if an error occurrs attempting to determine the default printer. --*/ { HRESULT hr = E_INVALIDARG; if (pszPrinterName) { WCHAR szBuffer[MAX_PATH*2]; DWORD dwError = ERROR_SUCCESS; DWORD cbData = sizeof(szBuffer); // // Read the default printer, if one exists. // dwError = RegQueryValueEx(pUser->hKeyWindows, szDevice, NULL, NULL, (PBYTE)szBuffer, &cbData); if (dwError == ERROR_SUCCESS) { PWSTR p = wcschr(szBuffer, L','); if (p) { *p = 0; } hr = !_wcsicmp(pszPrinterName, szBuffer) ? S_OK : S_FALSE; } else { hr = HRESULT_FROM_WIN32(dwError); } } return hr; } DWORD ReadPrinters( PINIT_REG_USER pUser, DWORD Flags, PDWORD pcbPrinters, LPBYTE* ppPrinters) { BOOL bSuccess = FALSE; DWORD cbNeeded = 0; DWORD cPrinters = 0; LPBYTE pPrinters = NULL; if (Flags == PRINTER_ENUM_CONNECTIONS) { bSuccess = EnumerateConnectedPrinters(*ppPrinters, *pcbPrinters, &cbNeeded, &cPrinters, pUser->hKeyUser); } else { bSuccess = EnumPrinters(Flags, NULL, 2, (PBYTE)*ppPrinters, *pcbPrinters, &cbNeeded, &cPrinters); } if (!bSuccess && GetLastError() == ERROR_INSUFFICIENT_BUFFER) { // // If not enough space, realloc. // if (pPrinters = ReallocSplMem(*ppPrinters, 0, cbNeeded)) { *ppPrinters = pPrinters; pPrinters = NULL; *pcbPrinters = cbNeeded; bSuccess = TRUE; } else { bSuccess = FALSE; } if (bSuccess) { if (Flags == PRINTER_ENUM_CONNECTIONS) { bSuccess = EnumerateConnectedPrinters(*ppPrinters, *pcbPrinters, &cbNeeded, &cPrinters, pUser->hKeyUser); } else { bSuccess = EnumPrinters(Flags, NULL, 2, (PBYTE)*ppPrinters, *pcbPrinters, &cbNeeded, &cPrinters); } } } if (!bSuccess) { cPrinters = 0; } return cPrinters; } BOOL UpdatePrinterInfo( const PINIT_REG_USER pCurUser, LPCWSTR pszPrinterName, LPCWSTR pszPort, PDWORD pdwNetId ) /*++ Routine Description: Updates the printer information in the registry win.ini. Arguments: pCurUser - Information about the user. The following fields are used by this routine: hKeyDevices hKeyPrinterPorts bDefaultSearch (if true, read/writes to:) bDefaultFound szDefaultPrinter bFirstPrinterFound (if false, writes to:) szFirstPrinter pszPort - Port name. If NULL, generates NetId. pdwNetId - Pointer to NetId counter. This value will be incremented if the NetId is used. Return Value: --*/ { WCHAR szBuffer[MAX_PATH * 2]; LPWSTR p; DWORD dwCount = 0; DWORD cbLen; if (!pszPrinterName) return FALSE; // // Now we know the spooler is up, since the EnumPrinters succeeded. // Update all sections. // StringCchPrintf(szBuffer, MAX_PATH*2, L"%s,", szWinspool); dwCount = wcslen(szBuffer); if( !pszPort ){ HANDLE hToken; StringCchPrintf(&szBuffer[dwCount], MAX_PATH*2 - dwCount, L"%s%.2d:", szNetwork, *pdwNetId); (*pdwNetId)++; // // !! HACK !! // // Works 3.0b expects the printer port entry in the // [ports] section. // // This is in the per-machine part of the registry, but we // are updating it for each user. Fix later. // // We never remove the NeXX: entries from [ports] but since // the same entries will be used by all users, this is ok. // hToken = RevertToPrinterSelf(); WriteProfileString( szPorts, &szBuffer[dwCount], L"" ); if( hToken ){ ImpersonatePrinterClient( hToken ); } // // End Works 3.0b HACK // } else { StringCchCopy(&szBuffer[dwCount], MAX_PATH*2 - dwCount, pszPort); // // Get the first port only. // if ( p = wcschr(&szBuffer[dwCount], L',') ) *p = 0; } cbLen = (wcslen(szBuffer)+1) * sizeof(szBuffer[0]); RegSetValueEx(pCurUser->hKeyDevices, pszPrinterName, 0, REG_SZ, (PBYTE)szBuffer, cbLen); // // If the user has a default printer specified, then verify // that it exists. // if (pCurUser->bDefaultSearch) { pCurUser->bDefaultFound = !_wcsicmp(pszPrinterName, pCurUser->szDefaultPrinter); if (pCurUser->bDefaultFound) { StringCchPrintf(pCurUser->szDefaultPrinter, COUNTOF(pCurUser->szDefaultPrinter), L"%s,%s", pszPrinterName, szBuffer); pCurUser->bDefaultSearch = FALSE; } } if (!pCurUser->bFirstPrinterFound) { StringCchPrintf(pCurUser->szFirstPrinter, COUNTOF(pCurUser->szFirstPrinter), L"%s,%s", pszPrinterName, szBuffer); pCurUser->bFirstPrinterFound = TRUE; } StringCchCat(szBuffer, COUNTOF(szBuffer), szTimeouts); RegSetValueEx(pCurUser->hKeyPrinterPorts, pszPrinterName, 0, REG_SZ, (PBYTE)szBuffer, (wcslen(szBuffer)+1) * sizeof(szBuffer[0])); return TRUE; } VOID SpoolerInitAsync( PINIT_REG_USER pUser ) /*++ Routine Description: Asynchronously sets up the user's registry information Arguments: pUser - pointer to INIT_REG_USER containing user keys Return Values: NONE --*/ { if (InitializeRegUser(NULL, pUser)) { SetupRegForUsers(pUser, 1); } BroadcastMessage(BROADCAST_TYPE_CHANGEDEFAULT,0,0,0); FreeRegUser(pUser); FreeSplMem(pUser); } BOOL SpoolerInit( VOID ) /*++ Routine Description: Initializes just the current user. Arguments: NONE Return Value: TRUE if initialized or async init thread created successfully FALSE otherwise --*/ { BOOL bSuccess = FALSE; DWORD dwThreadId; HANDLE hThread; PINIT_REG_USER pUser; UpdateLogonTimeStamp (); if (!(pUser = AllocSplMem(sizeof(INIT_REG_USER)))) { return FALSE; } // // Enum just the current user. // pUser->hKeyUser = GetClientUserHandle(KEY_READ|KEY_WRITE); if (pUser->hKeyUser) { if (!Initialized) { // // Process the user initialization asynchronously if the spooler // hasn't completed it's initialization. // hThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) SpoolerInitAsync, (LPVOID) pUser, 0, &dwThreadId); if (hThread) { // // We assume that the async thread will succeed. // CloseHandle(hThread); bSuccess = TRUE; } else { FreeRegUser(pUser); FreeSplMem(pUser); } } else { if (InitializeRegUser(NULL, pUser)) { bSuccess = SetupRegForUsers(pUser, 1); } FreeRegUser(pUser); FreeSplMem(pUser); } } return bSuccess; } BOOL InitializeRegUser( LPWSTR pszSubKey, PINIT_REG_USER pUser ) /*++ Routine Description: Initialize a single users structure based on a HKEY_USERS subkey. Arguments: pszSubKey - if non-NULL initialize hKeyUser to this key pUser - structure to initialize Return Value: --*/ { HKEY hKey; LPWSTR p; BOOL bSecurityLoaded = FALSE, rc = FALSE; DWORD cbData, cbSD = 0, dwError, dwDisposition; PSECURITY_DESCRIPTOR pSD = NULL; HANDLE hToken = NULL; if (pszSubKey) { if (RegOpenKeyEx(HKEY_USERS, pszSubKey, 0, KEY_READ|KEY_WRITE, &pUser->hKeyUser) != ERROR_SUCCESS) { DBGMSG(DBG_WARNING, ("InitializeRegUser: RegOpenKeyEx failed\n")); goto Fail; } } // // Now attempt to set the security on these two keys to // their parent key. // dwError = RegOpenKeyEx(pUser->hKeyUser, szCurrentVersionPath, 0, KEY_READ, &hKey); if (!dwError) { dwError = RegGetKeySecurity(hKey, DACL_SECURITY_INFORMATION, pSD, &cbSD); if (dwError == ERROR_INSUFFICIENT_BUFFER) { pSD = AllocSplMem(cbSD); if (pSD) { if (!RegGetKeySecurity(hKey, DACL_SECURITY_INFORMATION, pSD, &cbSD)){ bSecurityLoaded = TRUE; } else { DBGMSG(DBG_WARNING, ("InitializeRegUser: RegGetKeySecurity failed %d\n", GetLastError())); } } } else { DBGMSG(DBG_WARNING, ("InitializeRegUser: RegGetKeySecurity failed %d\n", dwError)); } RegCloseKey(hKey); } else { DBGMSG(DBG_WARNING, ("InitializeRegUser: RegOpenKeyEx CurrentVersion failed %d\n", dwError)); } hToken = RevertToPrinterSelf(); // // Open up the right keys. // if (RegCreateKeyEx(pUser->hKeyUser, szRegDevicesPath, 0, szNULL, 0, KEY_ALL_ACCESS, NULL, &pUser->hKeyDevices, &dwDisposition) != ERROR_SUCCESS) { DBGMSG(DBG_WARNING, ("InitializeRegUser: RegCreateKeyEx1 failed %d\n", GetLastError())); goto Fail; } if (bSecurityLoaded) { RegSetKeySecurity(pUser->hKeyDevices, DACL_SECURITY_INFORMATION, pSD); } if (RegCreateKeyEx(pUser->hKeyUser, szRegPrinterPortsPath, 0, szNULL, 0, KEY_ALL_ACCESS, NULL, &pUser->hKeyPrinterPorts, &dwDisposition) != ERROR_SUCCESS) { DBGMSG(DBG_WARNING, ("InitializeRegUser: RegCreateKeyEx2 failed %d\n", GetLastError())); goto Fail; } if (bSecurityLoaded) { RegSetKeySecurity(pUser->hKeyPrinterPorts, DACL_SECURITY_INFORMATION, pSD); } // // First, attempt to clear out the keys by deleting them. // RegClearKey(pUser->hKeyDevices); RegClearKey(pUser->hKeyPrinterPorts); if (RegOpenKeyEx(pUser->hKeyUser, szRegWindowsPath, 0, KEY_READ|KEY_WRITE, &pUser->hKeyWindows) != ERROR_SUCCESS) { DBGMSG(DBG_WARNING, ("InitializeRegUser: RegOpenKeyEx failed %d\n", GetLastError())); goto Fail; } pUser->bFoundPrinter = FALSE; pUser->bDefaultSearch = FALSE; pUser->bDefaultFound = FALSE; pUser->bFirstPrinterFound = FALSE; pUser->dwNetCounter = 0; cbData = sizeof(pUser->szDefaultPrinter); if (RegQueryValueEx(pUser->hKeyWindows, szDevice, NULL, NULL, (PBYTE)pUser->szDefaultPrinter, &cbData) == ERROR_SUCCESS) { pUser->bDefaultSearch = TRUE; } // // Remove the Device= in [windows] // RegDeleteValue(pUser->hKeyWindows, szDevice); if (!pUser->bDefaultSearch) { // // Attempt to read from saved location. // if (RegOpenKeyEx(pUser->hKeyUser, szPrinters, 0, KEY_READ, &hKey) == ERROR_SUCCESS) { cbData = sizeof(pUser->szDefaultPrinter); // // Try reading szDeviceOld. // if (RegQueryValueEx( hKey, szDeviceOld, NULL, NULL, (PBYTE)pUser->szDefaultPrinter, &cbData) == ERROR_SUCCESS) { pUser->bDefaultSearch = TRUE; } RegCloseKey(hKey); } } if ( pUser->bDefaultSearch ) { pUser->szDefaultPrinter[COUNTOF(pUser->szDefaultPrinter) - 1] = '\0'; if (p = wcschr(pUser->szDefaultPrinter, L',')) { *p = 0; } } rc = TRUE; Fail: if (hToken) { ImpersonatePrinterClient(hToken); } if (pSD) { FreeSplMem(pSD); } if (!rc) FreeRegUser(pUser); return rc; } VOID FreeRegUser( PINIT_REG_USER pUser) /*++ Routine Description: Free up the INIT_REG_USER structure intialized by InitializeRegUser. Arguments: Return Value: --*/ { if (pUser->hKeyUser) { RegCloseKey(pUser->hKeyUser); pUser->hKeyUser = NULL; } if (pUser->hKeyDevices) { RegCloseKey(pUser->hKeyDevices); pUser->hKeyDevices = NULL; } if (pUser->hKeyPrinterPorts) { RegCloseKey(pUser->hKeyPrinterPorts); pUser->hKeyPrinterPorts = NULL; } if (pUser->hKeyWindows) { RegCloseKey(pUser->hKeyWindows); pUser->hKeyWindows = NULL; } } VOID UpdatePrinterRegAll( LPWSTR pszPrinterName, LPWSTR pszPort, BOOL bDelete ) /*++ Routine Description: Updates everyone's [devices] and [printerports] sections (for local printers only). Arguments: pszPrinterName - printer that has been added/deleted pszPort - port name; if NULL, generate NetId bDelete - if TRUE, delete entry instead of updating it. Return Value: --*/ { WCHAR szKey[MAX_PATH]; DWORD cchKey; DWORD i; FILETIME ftLastWriteTime; DWORD dwError; // // Go through all keys and fix them up. // for (i=0; TRUE; i++) { cchKey = COUNTOF(szKey); dwError = RegEnumKeyEx(HKEY_USERS, i, szKey, &cchKey, NULL, NULL, NULL, &ftLastWriteTime); if (dwError != ERROR_SUCCESS) break; if (!_wcsicmp(szKey, szDotDefault) || wcschr(szKey, L'_')) continue; UpdatePrinterRegUser(NULL, szKey, pszPrinterName, pszPort, bDelete); } } DWORD UpdatePrinterRegUser( HKEY hKeyUser, LPWSTR pszUserKey, LPWSTR pszPrinterName, LPWSTR pszPort, BOOL bDelete ) /*++ Routine Description: Update one user's registry. The user is specified by either hKeyUser or pszUserKey. Arguments: hKeyUser - Clients user key (ignored if pszKey specified) pszUserKey - Clients SID (Used if supplied instead of hKeyUser) pszPrinterName - name of printe to add pszPort - port name; if NULL, generate NetId bDelete - if TRUE, delete entry instead of updating. Return Value: NOTE: We never cleanup [ports] since it is per-user EITHER hKeyUser or pszUserKey must be valid, but not both. --*/ { HKEY hKeyClose = NULL; HKEY hKeyRoot; DWORD dwError; WCHAR szBuffer[MAX_PATH]; DWORD dwNetId; INIT_REG_USER InitRegUser; ZeroMemory(&InitRegUser, sizeof(InitRegUser)); InitRegUser.hKeyDevices = NULL; InitRegUser.hKeyPrinterPorts = NULL; InitRegUser.bDefaultSearch = FALSE; InitRegUser.bFirstPrinterFound = TRUE; // // Setup the registry keys. // if (pszUserKey) { dwError = RegOpenKeyEx( HKEY_USERS, pszUserKey, 0, KEY_READ|KEY_WRITE, &hKeyRoot ); if (dwError != ERROR_SUCCESS) { goto Done; } hKeyClose = hKeyRoot; } else { hKeyRoot = hKeyUser; } dwError = RegOpenKeyEx(hKeyRoot, szRegDevicesPath, 0, KEY_READ|KEY_WRITE, &InitRegUser.hKeyDevices); if (dwError != ERROR_SUCCESS) goto Done; dwError = RegOpenKeyEx(hKeyRoot, szRegWindowsPath, 0, KEY_READ|KEY_WRITE, &InitRegUser.hKeyWindows); if (dwError != ERROR_SUCCESS) goto Done; // // Setup [PrinterPorts] // dwError = RegOpenKeyEx(hKeyRoot, szRegPrinterPortsPath, 0, KEY_WRITE, &InitRegUser.hKeyPrinterPorts); if (dwError != ERROR_SUCCESS) goto Done; if (!bDelete) { pszPort = CheckBadPortName( pszPort ); if( !pszPort ){ dwNetId = GetNetworkIdWorker(InitRegUser.hKeyDevices, pszPrinterName); } InitRegUser.bFirstPrinterFound = FALSE; UpdatePrinterInfo( &InitRegUser, pszPrinterName, pszPort, &dwNetId ); UpdateUsersDefaultPrinter( &InitRegUser, TRUE ); } else { HKEY hKeyDevMode; // // Delete the entries. // RegDeleteValue(InitRegUser.hKeyDevices, pszPrinterName); RegDeleteValue(InitRegUser.hKeyPrinterPorts, pszPrinterName); // // Check if the printer we are deleting is currently the // default printer. // if (IsUsersDefaultPrinter(&InitRegUser, pszPrinterName) == S_OK) { // // Remove the default printer from the registry. // RegDeleteValue(InitRegUser.hKeyWindows, szDevice); } // // Also delete DevModes2 entry from registry // dwError = RegOpenKeyEx( hKeyRoot, szDevModes2Path, 0, KEY_WRITE, &hKeyDevMode ); if (dwError == ERROR_SUCCESS) { // // Delete the devmode value entry for the particular printer // RegDeleteValue(hKeyDevMode, pszPrinterName); RegCloseKey(hKeyDevMode); } // // Remove the per-user DevMode. // bSetDevModePerUser( hKeyRoot, pszPrinterName, NULL ); } Done: if( InitRegUser.hKeyDevices ){ RegCloseKey( InitRegUser.hKeyDevices ); } if( InitRegUser.hKeyWindows ){ RegCloseKey( InitRegUser.hKeyWindows ); } if( InitRegUser.hKeyPrinterPorts ){ RegCloseKey( InitRegUser.hKeyPrinterPorts ); } if( hKeyClose ){ RegCloseKey( hKeyClose ); } return dwError; } VOID RegClearKey( HKEY hKey ) { DWORD dwError; WCHAR szValue[MAX_PATH]; DWORD cchValue; while (TRUE) { cchValue = COUNTOF(szValue); dwError = RegEnumValue(hKey, 0, szValue, &cchValue, NULL, NULL, NULL, NULL); if (dwError != ERROR_SUCCESS) { if( dwError != ERROR_NO_MORE_ITEMS ){ DBGMSG( DBG_WARN, ( "RegClearKey: RegEnumValue failed %d\n", dwError )); } break; } dwError = RegDeleteValue(hKey, szValue); if( dwError != ERROR_SUCCESS) { DBGMSG( DBG_WARN, ( "RegClearKey: RegDeleteValue failed %d\n", dwError )); break; } } } LPWSTR CheckBadPortName( LPWSTR pszPort ) /*++ Routine Description: This routine checks whether a port name should be converted to NeXX:. Currently if the port is NULL, or "\\*," or has a space, we convert to NeXX. Arguments: pszPort - port to check Return Value: pszPort - if port is OK. NULL - if port needs to be converted --*/ { // // If we have no pszPort, OR // it begins with '\\' (as in \\server\share) OR // it has a space in it OR // it's length is greater than 5 ("LPT1:") // Then // use NeXX: // // Most 16 bit apps can't deal with long port names, since they // allocate small buffers. // if( !pszPort || ( pszPort[0] == L'\\' && pszPort[1] == L'\\' ) || wcschr( pszPort, L' ' ) || wcslen( pszPort ) > 5 ){ return NULL; } return pszPort; } BOOL UpdateLogonTimeStamp( void ) { long lstatus; HKEY hProvidersKey = NULL; FILETIME LogonTime; LPWSTR szPrintProviders = L"SYSTEM\\CurrentControlSet\\Control\\Print\\Providers"; LPWSTR szLogonTime = L"LogonTime"; GetSystemTimeAsFileTime (&LogonTime); // Create (if not already present) and open Connections subkey lstatus = RegCreateKeyEx(HKEY_LOCAL_MACHINE, szPrintProviders, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_SET_VALUE, NULL, &hProvidersKey, NULL); if (lstatus == ERROR_SUCCESS) { lstatus = RegSetValueEx (hProvidersKey, szLogonTime, 0, REG_BINARY, (LPBYTE) &LogonTime, sizeof (FILETIME)); RegCloseKey(hProvidersKey); } return lstatus == ERROR_SUCCESS; } /*++ Routine Name AllowRemoteCalls Routine Description: This chains into the server and tells it to allow remote calls on the RPC interface. Note that this is reference counted. Arguments: None Return Value: An HRESULT --*/ HRESULT AllowRemoteCalls( VOID ) { HRESULT hr = (gpServerExports && gpServerExports->FnAllowRemoteCalls) ? S_OK : E_UNEXPECTED; if (SUCCEEDED(hr)) { hr = gpServerExports->FnAllowRemoteCalls(); } return hr; } /*++ Routine Name GetServerPolicy Routine Description: This chains into the server and gets a numeric policy read by the server. Arguments: pszPolicyName - policy name pValue - pointer to numeric value Return Value: An HRESULT --*/ HRESULT GetServerPolicy( IN PCWSTR pszPolicyName, IN ULONG* pValue ) { HRESULT hr = (gpServerExports && gpServerExports->FnGetServerPolicy) ? S_OK : E_UNEXPECTED; if (SUCCEEDED(hr)) { hr = (pValue && pszPolicyName) ? S_OK : E_POINTER; if (SUCCEEDED(hr)) { hr = gpServerExports->FnGetServerPolicy(pszPolicyName, pValue); } } return hr; }