/*************************************************************************** * * File Name: hpalerts.cpp * * Copyright (C) 1993-1996 Hewlett-Packard Company. * All rights reserved. * * 11311 Chinden Blvd. * Boise, Idaho 83714 * * This is a part of the HP JetAdmin Printer Utility * * This source code is only intended as a supplement for support and * localization of HP JetAdmin by 3rd party Operating System vendors. * Modification of source code cannot be made without the express written * consent of Hewlett-Packard. * * * Description: * * Author: Name * * * Modification history: * * date initials change description * * mm-dd-yy MJB * * * * * * ***************************************************************************/ #include #include #ifdef _DEBUG #undef THIS_FILE static char BASED_CODE THIS_FILE[] = __FILE__; #endif static AFX_EXTENSION_MODULE hpalertsDLL = { NULL, NULL }; #include ".\resource.h" #include ".\popup.h" #include #include #include #include #include // Internal functions DWORD MapStatusToAlert(DWORD dwStatus); HPERIPHERAL AlertsGetPrinterHandleByRegEntry(LPALERTENTRY lpEntry); #define NOTIFY_POPUP 0 #define NOTIFY_SOUNDS 1 #define NOTIFY_LOGGING 2 static TCHAR gszClassName[] = HPJETADMIN; static TCHAR gszAlerts[] = ALERT_ROOT; static TCHAR gszAlertsPrinters[] = ALERT_ROOT_PRINTERS; static TCHAR gszAlertsPopup[] = ALERT_ROOT_POPUP; static TCHAR gszAlertsSounds[] = ALERT_ROOT_SOUNDS; static TCHAR gszAlertsLogging[] = ALERT_ROOT_LOGGING; static TCHAR gszNotifyPopup[] = POPUP; static TCHAR gszNotifySounds[] = SOUNDS; static TCHAR gszNotifyLogging[] = LOGGING; static TCHAR gszBuffer[] = BUFFER; static TCHAR gszEnabled[] = ENABLED; static TCHAR gszStatus[] = STATUS; static TCHAR gszUpdateInterval[] = UPDATE_INTERVAL; HINSTANCE hInst = NULL; HWND m_hwnd = NULL; LPALERTENTRY m_lpAlertsTable = NULL; DWORD m_dwNumAlertsPrinters = 0; extern "C" int APIENTRY DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved) { if (dwReason == DLL_PROCESS_ATTACH) { TRACE0(TEXT("HPALERTS.DLL Initializing!\n\r")); // Extension DLL one-time initialization AfxInitExtensionModule(hpalertsDLL, hInstance); hInst = hInstance; // Insert this DLL into the resource chain new CDynLinkLibrary(hpalertsDLL); } else if (dwReason == DLL_PROCESS_DETACH) { TRACE0(TEXT("HPALERTS.DLL Terminating!\n\r")); hInst = NULL; } return 1; // ok } extern "C" DLL_EXPORT(DWORD) CALLING_CONVEN AlertsInit(HWND hWnd) { DWORD dwKeyDisposition; HKEY hKeyRoot; HKEY hKeyPrinters; DWORD dwSizeNeeded; PROCENTRY("HPALERTS: AlertsInit"); m_hwnd = hWnd; if (RegOpenKeyEx(HKEY_CURRENT_USER, gszAlerts, 0, KEY_ALL_ACCESS, &hKeyRoot) != ERROR_SUCCESS) { if (RegCreateKeyEx(HKEY_CURRENT_USER, gszAlerts, 0, gszClassName, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKeyRoot, &dwKeyDisposition) != ERROR_SUCCESS) { TRACE0(TEXT("HPALERTS: AlertsInit, failed to create registry key.\n\r")); PROCEXIT("HPALERTS: AlertsInit"); return RC_FAILURE; } } ASSERT(hKeyRoot); RegCloseKey(hKeyRoot); if (RegOpenKeyEx(HKEY_CURRENT_USER, gszAlertsPrinters, 0, KEY_ALL_ACCESS, &hKeyPrinters) != ERROR_SUCCESS) { if (RegCreateKeyEx(HKEY_CURRENT_USER, gszAlertsPrinters, 0, gszClassName, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKeyPrinters, &dwKeyDisposition) != ERROR_SUCCESS) { TRACE0(TEXT("HPALERTS: AlertsInit, failed to create alerts printers registry key.\n\r")); PROCEXIT("HPALERTS: AlertsInit"); return RC_FAILURE; } } ASSERT(hKeyPrinters); RegCloseKey(hKeyPrinters); AlertsGetPrinters(NULL, &dwSizeNeeded); if ( dwSizeNeeded > 0 ) { m_lpAlertsTable = (LPALERTENTRY)HP_GLOBAL_ALLOC_DLL(dwSizeNeeded); AlertsGetPrinters(m_lpAlertsTable, &dwSizeNeeded); m_dwNumAlertsPrinters = dwSizeNeeded/sizeof(ALERTENTRY); } else { m_lpAlertsTable = 0; m_dwNumAlertsPrinters = 0; } PROCEXIT("HPALERTS: AlertsInit"); return RC_SUCCESS; } extern "C" DLL_EXPORT(DWORD) CALLING_CONVEN AlertsExit(void) { PROCENTRY("HPALERTS: AlertsExit"); m_hwnd = NULL; if ( m_lpAlertsTable ) HP_GLOBAL_FREE(m_lpAlertsTable); m_lpAlertsTable = NULL; m_dwNumAlertsPrinters = 0; PROCEXIT("HPALERTS: AlertsExit"); return RC_SUCCESS; } HPERIPHERAL AlertsGetPrinterHandleByRegEntry(LPALERTENTRY lpEntry) { HPERIPHERAL hPeripheral; BOOL bChanged = FALSE; DWORD dPort; TCHAR szRegString[64]; TCHAR szTemp[512]; HKEY hKey; DWORD dwDefProtocol = PTYPE_IPX; PROCENTRY("HPALERTS: AlertsGetPrinterHandleByRegEntry\r\n"); PALGetDefaultProtocol(0, &dwDefProtocol); hPeripheral = PALGetPeripheralByRegistryStr(lpEntry->regKey, &(lpEntry->macAddr), &bChanged); if ( hPeripheral ) { TRACE1(TEXT("AlertsGetPrinterHandleByRegEntry(), found %s\r\n"), lpEntry->regKey); if ( bChanged ) { // Update registry information -- new registry string and port number if ( LOCAL_DEVICE(hPeripheral) ) DBGetRegistryStrEx(hPeripheral, PTYPE_LOCAL, szRegString); else DBGetRegistryStrEx(hPeripheral, PTYPE_NETWORK | dwDefProtocol, szRegString); // Get port number DBGetPortNumber(hPeripheral, &dPort); // Save in printer entry _tcscpy(szTemp, ALERT_ROOT_PRINTERS); _tcscat(szTemp, TEXT("\\")); _tcscat(szTemp, lpEntry->printerName); if ( RegOpenKeyEx(HKEY_CURRENT_USER, szTemp, 0L, KEY_ALL_ACCESS, &hKey) IS ERROR_SUCCESS ) { RegSetValueEx(hKey, PLIST_REGKEY, NULL, REG_SZ, (LPBYTE)szRegString, STRLENN_IN_BYTES(szRegString)); RegSetValueEx(hKey, HPPROPTY_PORTNUM, 0L, REG_DWORD, (LPBYTE)&(dPort), sizeof(DWORD)); RegCloseKey(hKey); } } } PROCEXIT("HPALERTS: AlertsGetPrinterHandleByRegEntry"); return(hPeripheral); } extern "C" DLL_EXPORT(void) CALLING_CONVEN AlertsGetPrinters(LPALERTENTRY lpAlertList, LPDWORD dwBufferSize) { int i; DWORD dwReturnCode, dwSize; HKEY hPrinterList, hPrinterKey; TCHAR szName[MAX_PATH], szRegKey[128]; LPALERTENTRY lpEntry; PROCENTRY("HPALERTS: AlertsGetPrinters"); if ( lpAlertList ) memset(lpAlertList, 0, *dwBufferSize); else *dwBufferSize = 0; // If the table has entries, just return the table. if ( m_dwNumAlertsPrinters > 0 ) { if ( lpAlertList ) { memcpy(lpAlertList, m_lpAlertsTable, sizeof(ALERTENTRY) * m_dwNumAlertsPrinters); } else *dwBufferSize = m_dwNumAlertsPrinters * sizeof(ALERTENTRY); return; } // Build the table from the registry dwReturnCode = RegCreateKey(HKEY_CURRENT_USER, ALERT_ROOT_PRINTERS, &hPrinterList); lpEntry = m_lpAlertsTable; for ( i = 0; ( dwReturnCode IS ERROR_SUCCESS ); i++ ) { if ( (dwReturnCode = RegEnumKey(hPrinterList, i, szName, sizeof(szName))) IS ERROR_SUCCESS ) { if ( lpEntry ) { // Init fields for entry _tcscpy(lpEntry->printerName, szName); lpEntry->regKey[0] = '\0'; hPrinterKey = NULL; dwReturnCode = RegOpenKey(hPrinterList, szName, &hPrinterKey); if ( dwReturnCode IS ERROR_SUCCESS ) { dwSize = sizeof(szRegKey); if ( RegQueryValueEx(hPrinterKey, PLIST_REGKEY, NULL, NULL, (LPBYTE)szRegKey, &dwSize) IS ERROR_SUCCESS ) _tcscpy(lpEntry->regKey, szRegKey); // Get hardware address and port number info also dwSize = sizeof(MACAddress); RegQueryValueEx(hPrinterKey, HPPROPTY_MACADDR, NULL, NULL, (LPBYTE)&(lpEntry->macAddr), &dwSize); dwSize = sizeof(DWORD); RegQueryValueEx(hPrinterKey, HPPROPTY_PORTNUM, NULL, NULL, (LPBYTE)&(lpEntry->dwPort), &dwSize); dwSize = sizeof(DWORD); RegQueryValueEx(hPrinterKey, HPPROPTY_FLAGS, NULL, NULL, (LPBYTE)&(lpEntry->dFlags), &dwSize); lpEntry->hPeripheral = AlertsGetPrinterHandleByRegEntry(lpEntry); lpEntry++; RegCloseKey(hPrinterKey); } // If a buffer is passed and the current alert count was 0 before we are building the internal // table, so we are also calculating the total number m_dwNumAlertsPrinters++; } else *dwBufferSize += sizeof(ALERTENTRY); } } RegCloseKey(hPrinterList); if ( lpAlertList IS NULL ) TRACE1(TEXT("AlertsGetPrinters: dwBufferSize: %d\r\n"), *dwBufferSize); PROCEXIT("HPALERTS: AlertsGetPrinters"); } DWORD AlertsEnumPeripherals(ALERTSENUMPROC lpfnEnumProc) { int i; HPERIPHERAL hPeripheral; LPALERTENTRY lpEntry = m_lpAlertsTable; PROCENTRY("HPALERTS: AlertsEnumPeripherals"); for ( i = 0; i < (int)m_dwNumAlertsPrinters; i++ ) { hPeripheral = AlertsGetPrinterHandleByRegEntry(lpEntry); if ( hPeripheral ) (lpfnEnumProc)(hPeripheral, lpEntry); else TRACE1(TEXT("HPALERTS: AlertsEnumPeripherals - no hPeripheral for %s\n\r"), lpEntry->printerName); lpEntry++; } PROCEXIT("HPALERTS: AlertsEnumPeripherals"); return RC_SUCCESS; } extern "C" DLL_EXPORT(DWORD) CALLING_CONVEN AlertsEnumPrinterNames(ALERTSPRINTERNAMEENUMPROC lpfnEnumProc) { int i; LPALERTENTRY lpEntry = m_lpAlertsTable; PROCENTRY("HPALERTS: AlertsEnumPrinterNames"); if ( lpfnEnumProc IS NULL ) return(RC_FAILURE); for ( i = 0; i < (int)m_dwNumAlertsPrinters; i++ ) { (lpfnEnumProc)(lpEntry->printerName); lpEntry++; } PROCEXIT("HPALERTS: AlertsEnumPrinterNames"); return(RC_SUCCESS); } extern "C" DLL_EXPORT(DWORD) CALLING_CONVEN AlertsRemoveAllPeripherals(void) { DWORD dwReturnCode = RC_SUCCESS, dwSubKey, dwSizeName, dwSizeClass; TCHAR szName[64], szClass[64]; FILETIME fileTime; HKEY hKeyPrinters; PROCENTRY("HPALERTS: AlertsRemoveAllPeripherals"); // Free alerts table, this will be allocate again the next time // someone calls AlertsGetPrinters if ( m_lpAlertsTable ) HP_GLOBAL_FREE(m_lpAlertsTable); m_lpAlertsTable = NULL; m_dwNumAlertsPrinters = 0; if (RegOpenKeyEx(HKEY_CURRENT_USER, gszAlertsPrinters, 0, KEY_ALL_ACCESS, &hKeyPrinters) != ERROR_SUCCESS) { TRACE0(TEXT("HPALERTS: AlertsRemoveAllPeripherals - failed to open registry key.\n\r")); return(RC_FAILURE); } ASSERT(hKeyPrinters); dwSubKey = 0; while (dwSubKey != -1) { dwSizeName = sizeof(szName)/sizeof(TCHAR); dwSizeClass = sizeof(szClass)/sizeof(TCHAR); if (RegEnumKeyEx(hKeyPrinters, dwSubKey, szName, &dwSizeName, NULL, szClass, &dwSizeClass, &fileTime) != ERROR_SUCCESS) { dwSubKey = (UINT)-1; } else { if (HPRegDeleteKey(hKeyPrinters, szName) != ERROR_SUCCESS) { TRACE1(TEXT("HPALERTS: AlertsRemoveAllPeripherals, FAILURE! (%s)\n\r"), (LPCSTR)szName); dwReturnCode = RC_FAILURE; } } } RegCloseKey(hKeyPrinters); PROCEXIT("HPALERTS: AlertsRemoveAllPeripherals"); return dwReturnCode; } extern "C" DLL_EXPORT(DWORD) CALLING_CONVEN AlertsAddPeripheralByString(LPCTSTR szPrinterName) { DWORD dwKeyDisposition, dwReturnCode = RC_SUCCESS; HKEY hKey; HKEY hKeyPrinters; HPERIPHERAL hPeripheral; DWORD dwSize; PeripheralInfo periphInfo; TCHAR szRegString[256]; DWORD dPort; LPALERTENTRY lpEntry; MACAddress macAddr; DWORD dwDefProtocol = PTYPE_IPX; PROCENTRY("HPALERTS: AlertsAddPeripheralByString"); PALGetDefaultProtocol(0, &dwDefProtocol); hPeripheral = PALGetPeripheralByNameEx((LPTSTR)szPrinterName, PTYPE_ALL); if ( hPeripheral IS NULL ) return(RC_FAILURE); if (RegOpenKeyEx(HKEY_CURRENT_USER, gszAlertsPrinters, 0, KEY_ALL_ACCESS, &hKeyPrinters) != ERROR_SUCCESS) { TRACE0(TEXT("HPALERTS: AlertsAddPeripheralsByString - failed to open registry key.\n\r")); return(RC_FAILURE); } ASSERT(hKeyPrinters); dwSize = sizeof(PeripheralInfo); if (PALGetObject(hPeripheral, OT_PERIPHERAL_INFO, 0, &periphInfo, &dwSize) != RC_SUCCESS) { TRACE0(TEXT("HPALERTS: AlertsPrintersEnumProc, FAILURE! (OT_PERIPHERAL_INFO)\n\r")); return(RC_FAILURE); } if ( LOCAL_DEVICE(hPeripheral) ) DBGetRegistryStrEx(hPeripheral, PTYPE_LOCAL, szRegString); else DBGetRegistryStrEx(hPeripheral, PTYPE_NETWORK | dwDefProtocol, szRegString); DBGetPortNumber(hPeripheral, &dPort); dwSize = sizeof(macAddr); DBGetAddress(hPeripheral, ADDR_MAC, &macAddr, &dwSize); // Save in printer entry if ( RegCreateKeyEx(hKeyPrinters, periphInfo.smashedName, 0L, gszClassName, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey, &dwKeyDisposition) IS ERROR_SUCCESS ) { RegSetValueEx(hKey, PLIST_REGKEY, NULL, REG_SZ, (LPBYTE)szRegString, STRLENN_IN_BYTES(szRegString)); RegSetValueEx(hKey, HPPROPTY_PORTNUM, 0L, REG_DWORD, (LPBYTE)&(dPort), sizeof(DWORD)); RegSetValueEx(hKey, HPPROPTY_MACADDR, 0L, REG_BINARY, (LPBYTE)&(macAddr), sizeof(MACAddress)); RegCloseKey(hKey); } else return(RC_FAILURE); // Add new entry to table m_dwNumAlertsPrinters++; if ( m_dwNumAlertsPrinters IS 1 ) m_lpAlertsTable = (LPALERTENTRY)HP_GLOBAL_ALLOC_DLL(m_dwNumAlertsPrinters * sizeof(ALERTENTRY)); else m_lpAlertsTable = (LPALERTENTRY)HP_GLOBAL_REALLOC_DLL(m_lpAlertsTable, m_dwNumAlertsPrinters * sizeof(ALERTENTRY), GMEM_ZEROINIT); lpEntry = m_lpAlertsTable + ( m_dwNumAlertsPrinters - 1 ); memcpy(&(lpEntry->macAddr), &macAddr, sizeof(macAddr)); lpEntry->dwPort = dPort; lpEntry->dFlags = 0; lpEntry->hPeripheral = hPeripheral; _tcscpy(lpEntry->regKey, szRegString); _tcscpy(lpEntry->printerName, periphInfo.smashedName); RegCloseKey(hKeyPrinters); PROCEXIT("HPALERTS: AlertsAddPeripheralByString"); return(dwReturnCode); } extern "C" DLL_EXPORT(DWORD) CALLING_CONVEN AlertsAddPeripheral(HPERIPHERAL hPeripheral) { DWORD dwReturnCode = RC_SUCCESS; HKEY hKey; HKEY hKeyPrinters; MACAddress macAddr; TCHAR szRegString[256]; DWORD dPort; PeripheralInfo periphInfo; DWORD dwSize; DWORD dwKeyDisposition; LPALERTENTRY lpEntry; DWORD dwDefProtocol = PTYPE_IPX; PROCENTRY("HPALERTS: AlertsAddPeripheral"); PALGetDefaultProtocol(0, &dwDefProtocol); if (RegOpenKeyEx(HKEY_CURRENT_USER, gszAlertsPrinters, 0, KEY_ALL_ACCESS, &hKeyPrinters) != ERROR_SUCCESS) { TRACE0(TEXT("HPALERTS: AlertsAddPeripheral - failed to open registry key.\n\r")); return(RC_FAILURE); } ASSERT(hKeyPrinters); dwSize = sizeof(PeripheralInfo); if (PALGetObject(hPeripheral, OT_PERIPHERAL_INFO, 0, &periphInfo, &dwSize) != RC_SUCCESS) { TRACE0(TEXT("HPALERTS: AlertsPrintersEnumProc, FAILURE! (OT_PERIPHERAL_INFO)\n\r")); return(RC_FAILURE); } if ( LOCAL_DEVICE(hPeripheral) ) DBGetRegistryStrEx(hPeripheral, PTYPE_LOCAL, szRegString); else DBGetRegistryStrEx(hPeripheral, PTYPE_NETWORK | dwDefProtocol, szRegString); DBGetPortNumber(hPeripheral, &dPort); dwSize = sizeof(macAddr); DBGetAddress(hPeripheral, ADDR_MAC, &macAddr, &dwSize); // Save in printer entry if ( RegCreateKeyEx(hKeyPrinters, periphInfo.smashedName, 0L, gszClassName, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey, &dwKeyDisposition) IS ERROR_SUCCESS ) { RegSetValueEx(hKey, PLIST_REGKEY, NULL, REG_SZ, (LPBYTE)szRegString, STRLENN_IN_BYTES(szRegString)); RegSetValueEx(hKey, HPPROPTY_PORTNUM, 0L, REG_DWORD, (LPBYTE)&(dPort), sizeof(DWORD)); RegSetValueEx(hKey, HPPROPTY_MACADDR, 0L, REG_BINARY, (LPBYTE)&(macAddr), sizeof(MACAddress)); RegCloseKey(hKey); } else return(RC_FAILURE); // Add new entry to table m_dwNumAlertsPrinters++; if ( m_dwNumAlertsPrinters IS 1 ) m_lpAlertsTable = (LPALERTENTRY)HP_GLOBAL_ALLOC_DLL(m_dwNumAlertsPrinters * sizeof(ALERTENTRY)); else m_lpAlertsTable = (LPALERTENTRY)HP_GLOBAL_REALLOC_DLL(m_lpAlertsTable, m_dwNumAlertsPrinters * sizeof(ALERTENTRY), GMEM_ZEROINIT); lpEntry = m_lpAlertsTable + ( m_dwNumAlertsPrinters - 1 ); memcpy(&(lpEntry->macAddr), &macAddr, sizeof(macAddr)); lpEntry->dwPort = dPort; lpEntry->dFlags = 0; lpEntry->hPeripheral = hPeripheral; _tcscpy(lpEntry->regKey, szRegString); _tcscpy(lpEntry->printerName, periphInfo.smashedName); RegCloseKey(hKeyPrinters); PROCEXIT("HPALERTS: AlertsAddPeripheral"); return(dwReturnCode); } extern "C" DLL_EXPORT(BOOL) CALLING_CONVEN AlertsRenamePrinter(LPTSTR lpszOldName, LPTSTR lpszNewName) { int i; BOOL bFound = FALSE; DWORD dwReturnCode, dwSize, dwSizeClass, dwType, dwStatus; HKEY hKeyPrinters, hOldPrinterKey, hNewPrinterKey; TCHAR szName[80], szClass[64], szBuffer[256]; FILETIME fileTime; DWORD dwPort; DWORD dwFlags; MACAddress macAddr; PROCENTRY("HPALERTS: AlertsRenamePrinter"); dwReturnCode = RegOpenKeyEx(HKEY_CURRENT_USER, gszAlertsPrinters, 0, KEY_ALL_ACCESS, &hKeyPrinters); for ( i = 0; ( ( dwReturnCode IS ERROR_SUCCESS ) AND !bFound ); i++ ) { dwSize = sizeof(szName)/sizeof(TCHAR); dwSizeClass = sizeof(szClass)/sizeof(TCHAR); if ( (dwReturnCode = RegEnumKeyEx(hKeyPrinters, i, szName, &dwSize, NULL, szClass, &dwSizeClass, &fileTime)) IS ERROR_SUCCESS ) { if (_tcsicmp(szName, lpszOldName) IS 0) { bFound = TRUE; } } } // If the registry key was found then delete the registry entry with // the old name and recreate with the new name. if (bFound) { // First get the current values from the printer entry (to be restored later). if (RegOpenKeyEx(hKeyPrinters, szName, 0, KEY_ALL_ACCESS, &hOldPrinterKey) == ERROR_SUCCESS) { dwReturnCode = RegCreateKey(hKeyPrinters, lpszNewName, &hNewPrinterKey); if (dwReturnCode IS ERROR_SUCCESS) { // Add status dwType = REG_DWORD; dwSize = sizeof(dwStatus); dwStatus = ASYNCH_STATUS_UNKNOWN; dwReturnCode = RegQueryValueEx(hOldPrinterKey, gszStatus, 0, &dwType, (CONST LPBYTE)&dwStatus, &dwSize); RegSetValueEx(hNewPrinterKey, gszStatus, 0, REG_DWORD, (CONST LPBYTE)&dwStatus, sizeof(dwStatus)); // Add buffer dwType = REG_SZ; dwSize = sizeof(szBuffer); szBuffer[0] = '\0'; dwReturnCode = RegQueryValueEx(hOldPrinterKey, gszBuffer, 0, &dwType, (CONST LPBYTE)szBuffer, &dwSize); RegSetValueEx(hNewPrinterKey, gszBuffer, 0, REG_SZ, (CONST LPBYTE)szBuffer, STRLENN_IN_BYTES(szBuffer)); // Add MAC Address dwType = REG_BINARY; dwSize = sizeof(macAddr); memset(&macAddr, 0, sizeof(macAddr)); dwReturnCode = RegQueryValueEx(hOldPrinterKey, HPPROPTY_MACADDR, 0, &dwType, (CONST LPBYTE)&macAddr, &dwSize); RegSetValueEx(hNewPrinterKey, HPPROPTY_MACADDR, 0, REG_BINARY, (CONST LPBYTE)&macAddr, sizeof(macAddr)); // Add Port number dwSize = sizeof(dwPort); dwPort = 0; dwReturnCode = RegQueryValueEx(hOldPrinterKey, HPPROPTY_PORTNUM, 0, &dwType, (CONST LPBYTE)&dwPort, &dwSize); RegSetValueEx(hNewPrinterKey, HPPROPTY_PORTNUM, 0, REG_DWORD, (CONST LPBYTE)&dwPort, sizeof(dwStatus)); // Add flags dwSize = sizeof(dwFlags); dwFlags = 0; RegQueryValueEx(hOldPrinterKey, HPPROPTY_FLAGS, NULL, NULL, (LPBYTE)&dwFlags, &dwSize); RegSetValueEx(hNewPrinterKey, HPPROPTY_FLAGS, 0, REG_DWORD, (CONST LPBYTE)&dwFlags, sizeof(dwStatus)); RegCloseKey(hNewPrinterKey); } RegCloseKey(hOldPrinterKey); } // Delete the current key and add new key with new printer name. dwReturnCode = HPRegDeleteKey(hKeyPrinters, szName); if (dwReturnCode IS ERROR_SUCCESS) { } } RegCloseKey(hKeyPrinters); // Tray icons needs to know about the name change too. TrayRenamePrinter(lpszOldName, lpszNewName, HPPROPTY_PLIST); PROCEXIT("HPALERTS: AlertsRenamePrinter"); return (bFound); } extern "C" DLL_EXPORT(DWORD) CALLING_CONVEN AlertsGetNotification(LPCTSTR szType, LPNOTIFICATIONENTRY lpNotification, DWORD dwCount) { DWORD i, dwReturnCode = RC_SUCCESS, dwType, dwValue, dwSize, dwKeyDisposition, dwResult; HKEY hKeyNotifyRoot, hNotifyKey, hKeyRoot; TCHAR szBuffer[256]; PROCENTRY("HPALERTS: AlertsGetNotification"); if (RegOpenKeyEx(HKEY_CURRENT_USER, gszAlerts, 0, KEY_ALL_ACCESS, &hKeyRoot) != ERROR_SUCCESS) { TRACE0(TEXT("HPALERTS: AlertsGetNotification - failed to open registry key.\n\r")); return(RC_FAILURE); } ASSERT(hKeyRoot); dwResult = RegOpenKeyEx(hKeyRoot, szType, 0, KEY_ALL_ACCESS, &hKeyNotifyRoot); if ((dwResult != ERROR_SUCCESS) && (RegCreateKeyEx(hKeyRoot, szType, 0, gszClassName, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKeyNotifyRoot, &dwKeyDisposition) != ERROR_SUCCESS)) { TRACE1(TEXT("HPALERTS: AlertsGetNotification, FAILURE! (%s)\n\r"), (LPCSTR)szType); dwReturnCode = RC_FAILURE; } else { for (i = 0; i < dwCount; i++) { lpNotification[i].bEnabled = FALSE; dwResult = RegOpenKeyEx(hKeyNotifyRoot, lpNotification[i].szKey, 0, KEY_ALL_ACCESS, &hNotifyKey); if ((dwResult != ERROR_SUCCESS) && (RegCreateKeyEx(hKeyNotifyRoot, lpNotification[i].szKey, 0, gszClassName, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hNotifyKey, &dwKeyDisposition) != ERROR_SUCCESS)) { TRACE2(TEXT("HPALERTS: AlertsGetNotification, FAILURE! (%s, %s)\n\r"), (LPCSTR)szType, (LPCSTR)lpNotification[i].szKey); dwReturnCode = RC_FAILURE; } else { dwType = REG_DWORD; dwSize = sizeof(dwValue); if (RegQueryValueEx(hNotifyKey, gszEnabled, 0, &dwType, (CONST LPBYTE)&dwValue, &dwSize) IS ERROR_SUCCESS) { TRACE2(TEXT("HPALERTS: AlertsGetNotification: Event: %s, Type: %lu\n\r"), lpNotification[i].szKey, dwType); if ( dwType IS REG_SZ ) { // Old format convert to DWORD dwSize = sizeof(szBuffer); if (RegQueryValueEx(hNotifyKey, gszEnabled, 0, &dwType, (CONST LPBYTE)szBuffer, &dwSize) IS ERROR_SUCCESS) { dwValue = (szBuffer[0] == '1') ? 1 : 0; TRACE1(TEXT("<----HPALERTS: Converting to DWORD: %lu---->\n\r"), dwValue); RegSetValueEx(hNotifyKey, gszEnabled, 0, REG_DWORD, (CONST LPBYTE)&dwValue, sizeof(dwValue)); } } lpNotification[i].bEnabled = dwValue; } dwType = REG_SZ; dwSize = sizeof(szBuffer); if (RegQueryValueEx(hNotifyKey, gszBuffer, 0, &dwType, (CONST LPBYTE)szBuffer, &dwSize) != ERROR_SUCCESS) { szBuffer[0] = '\0'; } _tcscpy(lpNotification[i].szBuffer, szBuffer); RegCloseKey(hNotifyKey); } } RegCloseKey(hKeyNotifyRoot); } RegCloseKey(hKeyRoot); PROCEXIT("HPALERTS: AlertsGetNotification"); return dwReturnCode; } extern "C" DLL_EXPORT(DWORD) CALLING_CONVEN AlertsSetNotification(LPCTSTR szType, LPNOTIFICATIONENTRY lpNotification, DWORD dwCount) { DWORD i, dwReturnCode = RC_SUCCESS, dwKeyDisposition, dwResult; HKEY hKeyRoot, hKeyNotifyRoot, hNotifyKey; TCHAR szBuffer[256]; PROCENTRY("HPALERTS: AlertsSetNotification"); if (RegOpenKeyEx(HKEY_CURRENT_USER, gszAlerts, 0, KEY_ALL_ACCESS, &hKeyRoot) != ERROR_SUCCESS) { TRACE0(TEXT("HPALERTS: AlertsSetNotification - failed to open registry key.\n\r")); return(RC_FAILURE); } ASSERT(hKeyRoot); dwResult = RegOpenKeyEx(hKeyRoot, szType, 0, KEY_ALL_ACCESS, &hKeyNotifyRoot); if ((dwResult != ERROR_SUCCESS) && (RegCreateKeyEx(hKeyRoot, szType, 0, gszClassName, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKeyNotifyRoot, &dwKeyDisposition) != ERROR_SUCCESS)) { TRACE1(TEXT("HPALERTS: AlertsSetNotification, FAILURE! (%s)\n\r"), (LPCSTR)szType); dwReturnCode = RC_FAILURE; } else { for (i = 0; i < dwCount; i++) { dwResult = RegOpenKeyEx(hKeyNotifyRoot, lpNotification[i].szKey, 0, KEY_ALL_ACCESS, &hNotifyKey); if ((dwResult != ERROR_SUCCESS) && (RegCreateKeyEx(hKeyNotifyRoot, lpNotification[i].szKey, 0, gszClassName, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hNotifyKey, &dwKeyDisposition) != ERROR_SUCCESS)) { TRACE2(TEXT("HPALERTS: AlertsSetNotification, FAILURE! (%s, %s)\n\r"), (LPCSTR)szType, (LPCSTR)lpNotification[i].szKey); dwReturnCode = RC_FAILURE; } else { if (RegSetValueEx(hNotifyKey, gszStatus, 0, REG_DWORD, (CONST LPBYTE)&lpNotification[i].dwStatus, sizeof(DWORD)) != ERROR_SUCCESS) { TRACE2(TEXT("HPALERTS: AlertsSetNotification, FAILURE! (%s, %s, Status)\n\r"), (LPCSTR)szType, (LPCSTR)lpNotification[i].szKey); dwReturnCode = RC_FAILURE; } DWORD dwTemp = lpNotification[i].bEnabled; if (RegSetValueEx(hNotifyKey, gszEnabled, 0, REG_DWORD, (CONST LPBYTE)&dwTemp, sizeof(dwTemp)) != ERROR_SUCCESS) { TRACE2(TEXT("HPALERTS: AlertsSetNotification, FAILURE! (%s, %s, Enable)\n\r"), (LPCSTR)szType, (LPCSTR)lpNotification[i].szKey); dwReturnCode = RC_FAILURE; } _tcscpy(szBuffer, lpNotification[i].szBuffer); if (RegSetValueEx(hNotifyKey, gszBuffer, 0, REG_SZ, (CONST LPBYTE)szBuffer, STRLENN_IN_BYTES(szBuffer)) != ERROR_SUCCESS) { TRACE2(TEXT("HPALERTS: AlertsSetNotification, FAILURE! (%s, %s, Buffer)\n\r"), (LPCSTR)szType, (LPCSTR)lpNotification[i].szKey); dwReturnCode = RC_FAILURE; } RegCloseKey(hNotifyKey); } } RegCloseKey(hKeyNotifyRoot); } RegCloseKey(hKeyRoot); PROCEXIT("HPALERTS: AlertsSetNotification"); return dwReturnCode; } extern "C" DLL_EXPORT(DWORD) CALLING_CONVEN AlertsGetUpdateInterval(UINT *uSeconds) { HKEY hKeyRoot; DWORD dTemp, dTempSize, dwType; TCHAR szBuffer[64]; UINT uUpdateInterval; PROCENTRY("HPALERTS: AlertsGetUpdateInterval"); if (RegOpenKeyEx(HKEY_CURRENT_USER, gszAlerts, 0, KEY_ALL_ACCESS, &hKeyRoot) != ERROR_SUCCESS) { *uSeconds = ALERTS_UPDATE_INTERVAL; TRACE0(TEXT("HPALERTS: AlertsGetUpdateInterval - can't open key; returning default update interval.\n\r")); } else { dTempSize = sizeof(dTemp); if (RegQueryValueEx(hKeyRoot, gszUpdateInterval, 0, &dwType, (LPBYTE)&dTemp, &dTempSize) != ERROR_SUCCESS) { *uSeconds = ALERTS_UPDATE_INTERVAL; TRACE0(TEXT("HPALERTS: AlertsGetUpdateInterval - can't read registry value; returning default update interval.\n\r")); } else { if (dwType IS REG_DWORD) *uSeconds = dTemp; else { // Value is odd, so fix it to default or old string value dTemp = ALERTS_UPDATE_INTERVAL; // Not reading back proper value, so see if this is old string value + convert to dword if (dwType IS REG_SZ) { dTempSize = sizeof(szBuffer); if (RegQueryValueEx(hKeyRoot, gszUpdateInterval, 0, &dwType, (CONST LPBYTE)szBuffer, &dTempSize) IS ERROR_SUCCESS) { if (_stscanf(szBuffer, TEXT("%d"), &uUpdateInterval) == 1) { dTemp = (DWORD)uUpdateInterval; } } } *uSeconds = dTemp; RegSetValueEx(hKeyRoot, gszUpdateInterval, 0, REG_DWORD, (CONST BYTE *)&dTemp, sizeof(dTemp)); } } RegCloseKey(hKeyRoot); } PROCEXIT("HPALERTS: AlertsGetUpdateInterval"); return RC_SUCCESS; } extern "C" DLL_EXPORT(DWORD) CALLING_CONVEN AlertsSetUpdateInterval(UINT uSeconds) { DWORD dTemp, dRetCode = RC_SUCCESS; HKEY hKeyRoot; PROCENTRY("HPALERTS: AlertsSetUpdateInterval"); if (RegOpenKeyEx(HKEY_CURRENT_USER, gszAlerts, 0, KEY_ALL_ACCESS, &hKeyRoot) != ERROR_SUCCESS) { TRACE1(TEXT("HPALERTS: AlertsSetUpdateInterval failed to open registry key, error=%ld.\n\r"), GetLastError()); return(RC_FAILURE); } ASSERT(hKeyRoot); dTemp = (DWORD) uSeconds; if (RegSetValueEx(hKeyRoot, gszUpdateInterval, 0, REG_DWORD, (CONST BYTE *)&dTemp, sizeof(dTemp)) != ERROR_SUCCESS) { TRACE0(TEXT("HPALERTS: AlertsInit, FAILURE! (UpdateInterval), couldn't set\n\r")); dRetCode = RC_FAILURE; } RegCloseKey(hKeyRoot); PROCEXIT("HPALERTS: AlertsSetUpdateInterval"); return(dRetCode); } extern "C" DLL_EXPORT(DWORD) CALLING_CONVEN AlertsGetEnabled(BOOL *bEnabled) { HKEY hKeyRoot; DWORD dTemp, dTempSize, dwType; TCHAR szBuffer[64]; BOOL bEnabledTemp; PROCENTRY("HPALERTS: AlertsGetEnabled"); if (RegOpenKeyEx(HKEY_CURRENT_USER, gszAlerts, 0, KEY_ALL_ACCESS, &hKeyRoot) != ERROR_SUCCESS) { TRACE1(TEXT("HPALERTS: AlertsGetEnabled - failed to open registry key, error=%ld.\n\r"), GetLastError()); *bEnabled = ALERTS_ENABLED; } else { dTempSize = sizeof(dTemp); dwType = REG_DWORD; if (RegQueryValueEx(hKeyRoot, gszEnabled, 0, &dwType, (LPBYTE)&dTemp, &dTempSize) != ERROR_SUCCESS) { *bEnabled = ALERTS_ENABLED; TRACE0(TEXT("HPALERTS: AlertsGetEnabled - can't read registry value; returning default enabled.\n\r")); } else { if (dwType IS REG_DWORD) *bEnabled = (BOOL)dTemp; else { // Not reading proper value from registry, so reset to default dTemp = (DWORD)ALERTS_ENABLED; // First check to see if this is the old string value & just convert it if (dwType IS REG_SZ) { dTempSize = sizeof(szBuffer); if (RegQueryValueEx(hKeyRoot, gszUpdateInterval, 0, &dwType, (CONST LPBYTE)szBuffer, &dTempSize) IS ERROR_SUCCESS) { bEnabledTemp = (szBuffer[0] == '1'); dTemp = (DWORD)bEnabledTemp; } } *bEnabled = (BOOL)dTemp; RegSetValueEx(hKeyRoot, gszEnabled, 0, REG_DWORD, (CONST BYTE *)&dTemp, sizeof(dTemp)); } } RegCloseKey(hKeyRoot); } PROCEXIT("HPALERTS: AlertsGetEnabled"); return RC_SUCCESS; } extern "C" DLL_EXPORT(DWORD) CALLING_CONVEN AlertsSetEnabled(BOOL bEnabled) { HKEY hKeyRoot; DWORD dTemp, dRetCode = RC_SUCCESS; PROCENTRY("HPALERTS: AlertsSetEnabled"); if (RegOpenKeyEx(HKEY_CURRENT_USER, gszAlerts, 0, KEY_ALL_ACCESS, &hKeyRoot) != ERROR_SUCCESS) { TRACE1(TEXT("HPALERTS: AlertsSetEnabled, failed to open registry key, error=%ld.\n\r"), GetLastError()); return(RC_FAILURE); } ASSERT(hKeyRoot); dTemp = (DWORD)bEnabled; if (RegSetValueEx(hKeyRoot, gszEnabled, 0, REG_DWORD, (CONST BYTE *)&dTemp, sizeof(dTemp)) != ERROR_SUCCESS) { TRACE0(TEXT("HPALERTS: AlertsInit, FAILURE! (Enabled), couldn't set\n\r")); dRetCode = RC_FAILURE; } RegCloseKey(hKeyRoot); PROCEXIT("HPALERTS: AlertsSetEnabled"); return(dRetCode); } static void NotificationPopup(HPERIPHERAL hPeriph, PeripheralInfo *lpPeriphInfo, PeripheralStatus *lpPeriphStatus, CString *pStatusString, CString *pDataString) { PROCENTRY("HPALERTS: NotificationPopup"); TRACE2(TEXT("HPALERTS: NotificationPopup, %s, %s\n\r"), (LPCTSTR)*pStatusString, (LPCTSTR)*pDataString); if (m_hwnd) { PopupParamsStruct popupParams; popupParams.hPeriph = hPeriph; popupParams.lpPeriphInfo = lpPeriphInfo; popupParams.lpPeriphStatus = lpPeriphStatus; popupParams.lpszStatus = *pStatusString; DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_ALERT), m_hwnd, PopupDialogProc, (LPARAM)&popupParams); } PROCEXIT("HPALERTS: NotificationPopup"); } static void NotificationSounds(HPERIPHERAL hPeriph, PeripheralInfo *lpPeriphInfo, PeripheralStatus *lpPeriphStatus, CString *pStatusString, CString *pDataString) { PROCENTRY("HPALERTS: NotificationSounds"); TRACE2(TEXT("HPALERTS: NotificationSounds, %s, %s\n\r"), (LPCTSTR)*pStatusString, (LPCTSTR)*pDataString); if (!PlaySound(*pDataString, NULL, SND_ASYNC | SND_FILENAME | /*SND_NODEFAULT | */SND_NOSTOP)) { MessageBeep((UINT)-1); } PROCEXIT("HPALERTS: NotificationSounds"); } static void NotificationLogging(HPERIPHERAL hPeriph, PeripheralInfo *lpPeriphInfo, PeripheralStatus *lpPeriphStatus, CString *pStatusString, CString *pDataString) { FILE *fp = NULL; TCHAR str[128], str2[128]; //SYSTEMTIME sysTime; SYSTEMTIME localTime; //TIME_ZONE_INFORMATION tzInfo; //DWORD dRetCode; PROCENTRY("HPALERTS: NotificationLogging"); TRACE2(TEXT("HPALERTS: NotificationLogging, %s, %s\n\r"), (LPCTSTR)*pStatusString, (LPCTSTR)*pDataString); if ((fp = _tfopen(*pDataString, TEXT("at"))) ISNT NULL) { GetLocalTime(&localTime); GetDateFormat(MAKELCID(MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), SORT_DEFAULT), DATE_SHORTDATE, &localTime, NULL, str, sizeof(str)/sizeof(TCHAR)); GetTimeFormat(MAKELCID(MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), SORT_DEFAULT), TIME_NOSECONDS, &localTime, NULL, str2, sizeof(str2)/sizeof(TCHAR)); _ftprintf(fp, TEXT("%s %s,%s,%s\n"), str, str2, (LPCTSTR)lpPeriphInfo->name, (LPCTSTR)*pStatusString); fclose(fp); } PROCEXIT("HPALERTS: NotificationLogging"); } static void CheckNotification(UINT uNotifyType, HPERIPHERAL hPeriph, PeripheralInfo *lpPeriphInfo, PeripheralStatus *lpPeriphStatus, CString *pStatusString) { BOOL bEnabled; DWORD dwType, dwSize, dwValue, dwAlertStatus, dwStatus, dwSubKey = 0, dwSizeName, dwSizeClass; TCHAR *lpszNotifyType, szBuffer[16], szName[64], szClass[64]; FILETIME fileTime; HKEY hKeyNotifyRoot, hNotifyKey, hKeyRoot; PROCENTRY("HPALERTS: CheckNotification"); switch (uNotifyType) { case NOTIFY_POPUP: lpszNotifyType = gszNotifyPopup; break; case NOTIFY_SOUNDS: lpszNotifyType = gszNotifySounds; break; case NOTIFY_LOGGING: lpszNotifyType = gszNotifyLogging; break; } if (RegOpenKeyEx(HKEY_CURRENT_USER, gszAlerts, 0, KEY_ALL_ACCESS, &hKeyRoot) != ERROR_SUCCESS) { TRACE1(TEXT("HPALERTS: CheckNotification, failed to open registry key, error=%ld.\n\r"), GetLastError()); PROCEXIT("HPALERTS: CheckNotification"); return; } if (RegOpenKeyEx(hKeyRoot, lpszNotifyType, 0, KEY_ALL_ACCESS, &hKeyNotifyRoot) == ERROR_SUCCESS) { TRACE1(TEXT("HPALERTS: CheckNotification, %s...\n\r"), (LPCSTR)lpszNotifyType); while (dwSubKey != -1) { dwSizeName = sizeof(szName)/sizeof(TCHAR); dwSizeClass = sizeof(szClass)/sizeof(TCHAR); if (RegEnumKeyEx(hKeyNotifyRoot, dwSubKey, szName, &dwSizeName, NULL, szClass, &dwSizeClass, &fileTime) != ERROR_SUCCESS) { dwSubKey = (UINT)-1; } else { // TRACE2("HPALERTS: CheckNotification, %s, checking %s...\n\r", (LPCSTR)lpszNotifyType, (LPCSTR)szName); if (RegOpenKeyEx(hKeyNotifyRoot, szName, 0, KEY_ALL_ACCESS, &hNotifyKey) == ERROR_SUCCESS) { dwType = REG_DWORD; dwSize = sizeof(dwAlertStatus); if (RegQueryValueEx(hNotifyKey, gszStatus, 0, &dwType, (CONST LPBYTE)&dwAlertStatus, &dwSize) != ERROR_SUCCESS) { dwAlertStatus = ASYNCH_STATUS_UNKNOWN; } bEnabled = FALSE; dwType = REG_DWORD; dwSize = sizeof(dwValue); if (RegQueryValueEx(hNotifyKey, gszEnabled, 0, &dwType, (CONST LPBYTE)&dwValue, &dwSize) IS ERROR_SUCCESS) { if ( dwType IS REG_SZ ) { // Old format convert to DWORD dwSize = sizeof(szBuffer); if (RegQueryValueEx(hNotifyKey, gszEnabled, 0, &dwType, (CONST LPBYTE)szBuffer, &dwSize) IS ERROR_SUCCESS) { dwValue = (szBuffer[0] == '1') ? 1 : 0; TRACE1(TEXT("<----HPALERTS: Converting to DWORD: %lu---->\n\r"), dwValue); RegSetValueEx(hNotifyKey, gszEnabled, 0, REG_DWORD, (CONST LPBYTE)&dwValue, sizeof(dwValue)); } } else bEnabled = (BOOL)dwValue; } else bEnabled = FALSE; dwStatus = MapStatusToAlert(lpPeriphStatus->peripheralStatus); if (bEnabled && (dwAlertStatus == dwStatus)) { TRACE4(TEXT("--->HPALERTS: Alert Triggered, Event: %s...,enabled:%s, alert status: %lu, actual status: %lu\n\r"), (LPCSTR)szName, ( bEnabled IS TRUE ) ? "TRUE" : "FALSE", dwAlertStatus, lpPeriphStatus->peripheralStatus); CString cDataString; dwType = REG_SZ; dwSize = 512; // was 256 before unicode. if (RegQueryValueEx(hNotifyKey, gszBuffer, 0, &dwType, (LPBYTE)cDataString.GetBuffer(dwSize/sizeof(TCHAR)), &dwSize) != ERROR_SUCCESS) { cDataString = TEXT(""); } cDataString.ReleaseBuffer(); switch (uNotifyType) { case NOTIFY_POPUP: NotificationPopup(hPeriph, lpPeriphInfo, lpPeriphStatus, pStatusString, &cDataString); break; case NOTIFY_SOUNDS: NotificationSounds(hPeriph, lpPeriphInfo, lpPeriphStatus, pStatusString, &cDataString); break; case NOTIFY_LOGGING: NotificationLogging(hPeriph, lpPeriphInfo, lpPeriphStatus, pStatusString, &cDataString); break; } } RegCloseKey(hNotifyKey); } dwSubKey++; } } RegCloseKey(hKeyNotifyRoot); } RegCloseKey(hKeyRoot); PROCEXIT("HPALERTS: CheckNotification"); } extern "C" DLL_EXPORT(BOOL) CALLBACK AlertsPrintersEnumProc(HPERIPHERAL hPeriph, LPALERTENTRY lpEntry) { DWORD dwDeviceID, dwType, dwSize, dwStatus, dwResult; HKEY hKeyTemp, hKeyPrinters; PeripheralStatus periphStatus; PeripheralInfo periphInfo; PROCENTRY("HPALERTS: AlertsPrintersEnumProc"); // If the printer device ID is "unknown", set it to "undefined" so that // COLA will query the printer for its model info. This is needed if a // printer was off then turned on after the COLA database was built... // RAS // DBGetDeviceID(hPeriph, &dwDeviceID); if (dwDeviceID == PTR_UNDEF) DBSetDeviceID(hPeriph, 0xFF); dwSize = sizeof(PeripheralInfo); if (PALGetObject(hPeriph, OT_PERIPHERAL_INFO, 0, &periphInfo, &dwSize) != RC_SUCCESS) { TRACE0(TEXT("HPALERTS: AlertsPrintersEnumProc, FAILURE! (OT_PERIPHERAL_INFO)\n\r")); return(TRUE); } dwSize = sizeof(PeripheralStatus); if (PALGetObject(hPeriph, OT_PERIPHERAL_STATUS, 0, &periphStatus, &dwSize) == RC_SUCCESS) { if (RegOpenKeyEx(HKEY_CURRENT_USER, gszAlertsPrinters, 0, KEY_ALL_ACCESS, &hKeyPrinters) != ERROR_SUCCESS) { TRACE1(TEXT("HPALERTS: AlertsPrintersEnumProc, open registry key failed with error %ld.\n\r"), GetLastError()); PROCEXIT("HPALERTS: AlertsPrintersEnumProc"); return(FALSE); } if (RegOpenKeyEx(hKeyPrinters, lpEntry->printerName, 0, KEY_ALL_ACCESS, &hKeyTemp) == ERROR_SUCCESS) { dwType = REG_DWORD; dwSize = sizeof(dwStatus); dwResult = RegQueryValueEx(hKeyTemp, gszStatus, 0, &dwType, (CONST LPBYTE)&dwStatus, &dwSize); if ((dwResult != ERROR_SUCCESS) || (dwStatus != periphStatus.peripheralStatus)) { CString cString; ::LoadString(periphStatus.hResourceModule, periphStatus.statusResID, cString.GetBuffer(256), 256); cString.ReleaseBuffer(); TRACE3(TEXT("HPALERTS: AlertsPrintersEnumProc, updating registry..., %s (%d:%d)\n\r"), (LPCTSTR)cString, dwStatus, periphStatus.peripheralStatus); if (RegSetValueEx(hKeyTemp, gszStatus, 0, REG_DWORD, (CONST LPBYTE)&periphStatus.peripheralStatus, sizeof(DWORD)) != ERROR_SUCCESS) TRACE0(TEXT("HPALERTS: AlertsPrintersEnumProc, FAILURE! (Status)\n\r")); if (RegSetValueEx(hKeyTemp, gszBuffer, 0, REG_SZ, (CONST LPBYTE)(LPCTSTR)cString, cString.GetLength()*sizeof(TCHAR) + sizeof(TCHAR)) != ERROR_SUCCESS) TRACE0(TEXT("HPALERTS: AlertsPrintersEnumProc, FAILURE! (Buffer)\n\r")); if (dwResult == ERROR_SUCCESS) { // Check for sounds notification... // CheckNotification(NOTIFY_SOUNDS, hPeriph, &periphInfo, &periphStatus, &cString); // Check for logging notification... // CheckNotification(NOTIFY_LOGGING, hPeriph, &periphInfo, &periphStatus, &cString); // Check for popup notification... // CheckNotification(NOTIFY_POPUP, hPeriph, &periphInfo, &periphStatus, &cString); } } RegCloseKey(hKeyTemp); } RegCloseKey(hKeyPrinters); } PROCEXIT("HPALERTS: AlertsPrintersEnumProc"); return TRUE; } extern "C" DLL_EXPORT(DWORD) CALLING_CONVEN AlertsCheckFor(void) { BOOL bEnabled; PROCENTRY("HPALERTS: AlertsCheckFor"); if (AlertsGetEnabled(&bEnabled) IS RC_SUCCESS) { AlertsEnumPeripherals(AlertsPrintersEnumProc); } PROCEXIT("HPALERTS: AlertsCheckFor"); return RC_SUCCESS; } extern "C" DLL_EXPORT(DWORD) CALLING_CONVEN AlertsGetLoggingName(LPTSTR szBuffer, DWORD dwSize) { DWORD dwReturnCode = RC_FAILURE, dwType, dwSubKey = 0, dwSizeName, dwSizeClass, dwBufSize; TCHAR szName[64], szClass[64]; FILETIME fileTime; HKEY hKeyLogRoot, hLogKey; PROCENTRY("HPALERTS: AlertsGetLoggingName"); if (RegOpenKeyEx(HKEY_CURRENT_USER, gszAlertsLogging, 0, KEY_ALL_ACCESS, &hKeyLogRoot) != ERROR_SUCCESS) { PROCEXIT("HPALERTS: AlertsGetLoggingName"); return(dwReturnCode); } dwSizeName =SIZEOF_IN_CHAR(szName); dwSizeClass = SIZEOF_IN_CHAR(szClass); if (RegEnumKeyEx(hKeyLogRoot, dwSubKey, szName, &dwSizeName, NULL, szClass, &dwSizeClass, &fileTime) == ERROR_SUCCESS) { if (RegOpenKeyEx(hKeyLogRoot, szName, 0, KEY_ALL_ACCESS, &hLogKey) == ERROR_SUCCESS) { dwType = REG_SZ; dwBufSize = dwSize * sizeof(TCHAR); // RegQueryValueEx expects size in bytes. if (RegQueryValueEx(hLogKey, gszBuffer, 0, &dwType, (CONST LPBYTE)szBuffer, &dwBufSize) == ERROR_SUCCESS) { dwReturnCode = RC_SUCCESS; } RegCloseKey(hLogKey); } } RegCloseKey(hKeyLogRoot); PROCEXIT("HPALERTS: AlertsGetLoggingName"); return dwReturnCode; } extern "C" DLL_EXPORT(DWORD) CALLING_CONVEN AlertsReinitialize(void) { HWND hwnd; CString cString; if (hwnd = ::FindWindow(NULL, PROPTY_NAME)) { PostMessage(hwnd, MYWM_REINITIALIZE, 0, 0); } else { if (WinExec(PROPTY_EXE, SW_SHOW) <= 31) { TCHAR szCaption[64], szText[128]; LoadString(hInst, IDS_TRAY_ERROR_CAPTION, szCaption, SIZEOF_IN_CHAR(szCaption)); LoadString(hInst, IDS_NO_PROPERTIES, szText, SIZEOF_IN_CHAR(szText)); MessageBox(m_hwnd, szText, szCaption, MB_ICONEXCLAMATION | MB_OK | MB_SYSTEMMODAL); } } return RC_SUCCESS; } DWORD MapStatusToAlert(DWORD dwStatus) { DWORD dwAlert = dwStatus; // Default is to return same status as passed in. // The following status id's need to be mapped to the status id that // is saved in the registry for the associated alert entry. switch (dwStatus) { case ASYNCH_HCI_JAM: dwAlert = ASYNCH_PAPER_JAM; break; case ASYNCH_TRAY1_ADD: case ASYNCH_TRAY2_ADD: case ASYNCH_TRAY3_ADD: case ASYNCH_HCI_ADD: dwAlert = ASYNCH_PAPER_OUT; break; case ASYNCH_CLEAR_OUTPUT_BIN: dwAlert = ASYNCH_OUTPUT_BIN_FULL; break; } return dwAlert; }