void CFrameWnd::SetMessageText( UINT nID ) /****************************************/ { CString str; GetMessageString( nID, str ); SetMessageText( str ); }
LRESULT COleIPFrameWnd::OnSetMessageString(WPARAM wParam, LPARAM lParam) { USES_CONVERSION; if (m_lpFrame != NULL) { LPCTSTR lpsz = NULL; CString strMessage; // set the message bar text if (lParam != NULL) { ASSERT(wParam == 0); // can't have both an ID and a string lpsz = (LPCTSTR)lParam; // set an explicit string } else if (wParam != 0) { // get message associated with the ID indicated by wParam GetMessageString(wParam, strMessage); lpsz = strMessage; } // notify container of new status text if (lpsz == NULL) lpsz = &afxChNil; m_lpFrame->SetStatusText(T2COLE(lpsz)); } UINT nIDLast = m_nIDLastMessage; m_nIDLastMessage = (UINT)wParam; // new ID (or 0) m_nIDTracking = (UINT)wParam; // so F1 on toolbar buttons work return nIDLast; }
BOOL CAddSubmtDlg::OnInitDialog() { CDialog::OnInitDialog(); if (!m_bAdd) { SetWindowText(GetMessageString(IDS_EDIT_PATH_NAME)); ((CEdit *)GetDlgItem(IDC_SHARE_NAME))->EnableWindow(FALSE); } return TRUE; // return TRUE unless you set the focus to a control // EXCEPTION: OCX Property Pages should return FALSE }
// If the message string contains parameter insertion strings (for example, %%4096), // you must perform the parameter substitution yourself. To get the parameter message // string, call FormatMessage with the message identifier found in the parameter insertion // string (for example, 4096 is the message identifier if the parameter insertion string // is %%4096). You then substitute the parameter insertion string in the message // string with the actual parameter message string. // // In this example, the message string for message ID 0x103 is "%1 %%4096 = %2 %%4097.". // When you call FormatMessage to get the message string, FormatMessage returns // "8 %4096 = 2 %4097.". You need to replace %4096 and %4097 with the message strings // associated with message IDs 4096 and 4097, respectively. static DWORD ApplyParameterStringsToMessage(CONST LPCWSTR pMessage, LPWSTR & pFinalMessage) { DWORD status = ERROR_SUCCESS; DWORD dwParameterCount = 0; // Number of insertion strings found in pMessage size_t cbBuffer = 0; // Size of the buffer in bytes size_t cchBuffer = 0; // Size of the buffer in characters size_t cchParameters = 0; // Number of characters in all the parameter strings size_t cch = 0; DWORD i = 0; LPWSTR* pStartingAddresses = NULL; // Array of pointers to the beginning of each parameter string in pMessage LPWSTR* pEndingAddresses = NULL; // Array of pointers to the end of each parameter string in pMessage DWORD* pParameterIDs = NULL; // Array of parameter identifiers found in pMessage LPWSTR* pParameters = NULL; // Array of the actual parameter strings LPWSTR pTempMessage = (LPWSTR)pMessage; LPWSTR pTempFinalMessage = NULL; // Determine the number of parameter insertion strings in pMessage. while (pTempMessage = wcschr(pTempMessage, L'%')) { dwParameterCount++; pTempMessage++; } // If there are no parameter insertion strings in pMessage, return. if (0 == dwParameterCount) { pFinalMessage = NULL; goto cleanup; } // Allocate an array of pointers that will contain the beginning address // of each parameter insertion string. cbBuffer = sizeof(LPWSTR) * dwParameterCount; pStartingAddresses = (LPWSTR*)malloc(cbBuffer); if (NULL == pStartingAddresses) { wprintf(L"Failed to allocate memory for pStartingAddresses.\n"); status = ERROR_OUTOFMEMORY; goto cleanup; } RtlZeroMemory(pStartingAddresses, cbBuffer); // Allocate an array of pointers that will contain the ending address (one // character past the of the identifier) of the each parameter insertion string. pEndingAddresses = (LPWSTR*)malloc(cbBuffer); if (NULL == pEndingAddresses) { wprintf(L"Failed to allocate memory for pEndingAddresses.\n"); status = ERROR_OUTOFMEMORY; goto cleanup; } RtlZeroMemory(pEndingAddresses, cbBuffer); // Allocate an array of pointers that will contain pointers to the actual // parameter strings. pParameters = (LPWSTR*)malloc(cbBuffer); if (NULL == pParameters) { wprintf(L"Failed to allocate memory for pEndingAddresses.\n"); status = ERROR_OUTOFMEMORY; goto cleanup; } RtlZeroMemory(pParameters, cbBuffer); // Allocate an array of DWORDs that will contain the message identifier // for each parameter. pParameterIDs = (DWORD*)malloc(cbBuffer); if (NULL == pParameterIDs) { wprintf(L"Failed to allocate memory for pParameterIDs.\n"); status = ERROR_OUTOFMEMORY; goto cleanup; } RtlZeroMemory(pParameterIDs, cbBuffer); // Find each parameter in pMessage and get the pointer to the // beginning of the insertion string, the end of the insertion string, // and the message identifier of the parameter. pTempMessage = (LPWSTR)pMessage; while (pTempMessage = wcschr(pTempMessage, L'%')) { if (isdigit(*(pTempMessage+1))) { pStartingAddresses[i] = pTempMessage; pTempMessage++; pParameterIDs[i] = (DWORD)_wtoi(pTempMessage); while (isdigit(*++pTempMessage)) ; pEndingAddresses[i] = pTempMessage; i++; } } // For each parameter, use the message identifier to get the // actual parameter string. for (DWORD i = 0; i < dwParameterCount; i++) { pParameters[i] = GetMessageString(pParameterIDs[i], 0, NULL); if (NULL == pParameters[i]) { wprintf(L"GetMessageString could not find parameter string for insert %lu.\n", i); status = ERROR_INVALID_PARAMETER; goto cleanup; } cchParameters += wcslen(pParameters[i]); } // Allocate enough memory for pFinalMessage based on the length of pMessage // and the length of each parameter string. The pFinalMessage buffer will contain // the completed parameter substitution. pTempMessage = (LPWSTR)pMessage; cbBuffer = (wcslen(pMessage) + cchParameters + 1) * sizeof(WCHAR); pFinalMessage = (LPWSTR)malloc(cbBuffer); if (NULL == pFinalMessage) { wprintf(L"Failed to allocate memory for pFinalMessage.\n"); status = ERROR_OUTOFMEMORY; goto cleanup; } RtlZeroMemory(pFinalMessage, cbBuffer); cchBuffer = cbBuffer / sizeof(WCHAR); pTempFinalMessage = pFinalMessage; // Build the final message string. for (DWORD i = 0; i < dwParameterCount; i++) { // Append the segment from pMessage. In the first iteration, this is "8 " and in the // second iteration, this is " = 2 ". wcsncpy_s(pTempFinalMessage, cchBuffer, pTempMessage, cch = (pStartingAddresses[i] - pTempMessage)); pTempMessage = pEndingAddresses[i]; cchBuffer -= cch; // Append the parameter string. In the first iteration, this is "quarts" and in the // second iteration, this is "gallons" pTempFinalMessage += cch; wcscpy_s(pTempFinalMessage, cchBuffer, pParameters[i]); cchBuffer -= cch = wcslen(pParameters[i]); pTempFinalMessage += cch; } // Append the last segment from pMessage, which in this example is ".". wcscpy_s(pTempFinalMessage, cchBuffer, pTempMessage); cleanup: if (ERROR_SUCCESS != status) pFinalMessage = (LPWSTR)pMessage; if (pStartingAddresses) free(pStartingAddresses); if (pEndingAddresses) free(pEndingAddresses); if (pParameterIDs) free(pParameterIDs); for (DWORD i = 0; i < dwParameterCount; i++) { if (pParameters[i]) LocalFree(pParameters[i]); } return status; }
// Write the contents of each event record that was written to the log since // the last notification. The service signals the event object every five seconds // if an event has been written to the log. static DWORD DumpNewRecords(int index) { DWORD status = ERROR_SUCCESS; DWORD dwLastRecordNumber = 0; LPWSTR pMessage = NULL; LPWSTR pFinalMessage = NULL; PBYTE pRecord = NULL; HANDLE hEventLog = g_arrhEventLog[index]; // Read the first record to prime the loop. status = ReadRecord(hEventLog, pRecord, 0, EVENTLOG_SEQUENTIAL_READ | EVENTLOG_FORWARDS_READ); if (ERROR_SUCCESS != status && ERROR_HANDLE_EOF != status) { wprintf(L"ReadRecord (priming read) failed.\n"); goto cleanup; } // During the five second notification period, one or more records could // have been written to the log. Read all the records that have been // written since the last notification. int nMonSize = sizeof(event_monitor)/sizeof(struct _EVENT_MONITOR); while (ERROR_HANDLE_EOF != status) { int i = 0; for (; i<nMonSize; i++) { if (0 == wcscmp(event_monitor[i].provider_name, (LPWSTR)(pRecord + sizeof(EVENTLOGRECORD)))) { break; } } // If the event was written by our provider, write the contents of the event. //if (0 == wcscmp(PROVIDER_NAME, (LPWSTR)(pRecord + sizeof(EVENTLOGRECORD)))) if (i<nMonSize) { g_hResources = event_monitor[i].hResource; wprintf(L"record number: %lu\n", ((PEVENTLOGRECORD)pRecord)->RecordNumber); wprintf(L"status code: %d\n", ((PEVENTLOGRECORD)pRecord)->EventID & 0xFFFF); wprintf(L"event type: %s\n", pEventTypeNames[GetEventTypeName(((PEVENTLOGRECORD)pRecord)->EventType)]); pMessage = GetMessageString(((PEVENTLOGRECORD)pRecord)->EventCategory, 0, NULL); if (pMessage) { wprintf(L"event category: %s", pMessage); LocalFree(pMessage); pMessage = NULL; } pMessage = GetMessageString(((PEVENTLOGRECORD)pRecord)->EventID, ((PEVENTLOGRECORD)pRecord)->NumStrings, (LPWSTR)(pRecord + ((PEVENTLOGRECORD)pRecord)->StringOffset)); if (pMessage) { status = ApplyParameterStringsToMessage(pMessage, pFinalMessage); wprintf(L"event message: %s", (pFinalMessage) ? pFinalMessage : pMessage); if (event_monitor[i].FuncEventProcess) { event_monitor[i].FuncEventProcess((pFinalMessage) ? pFinalMessage : pMessage, GetEventTypeName(((PEVENTLOGRECORD)pRecord)->EventType)); } LocalFree(pMessage); pMessage = NULL; if (pFinalMessage) { free(pFinalMessage); pFinalMessage = NULL; } } // To write the event data, you need to know the format of the data. In // this example, we know that the event data is a null-terminated string. if (((PEVENTLOGRECORD)pRecord)->DataLength > 0) { wprintf(L"event data: %s\n", (LPWSTR)(pRecord + ((PEVENTLOGRECORD)pRecord)->DataOffset)); } wprintf(L"\n"); } // Read sequentially through the records. status = ReadRecord(hEventLog, pRecord, 0, EVENTLOG_SEQUENTIAL_READ | EVENTLOG_FORWARDS_READ); if (ERROR_SUCCESS != status && ERROR_HANDLE_EOF != status) { wprintf(L"ReadRecord sequential failed.\n"); goto cleanup; } } if (ERROR_HANDLE_EOF == status) { status = ERROR_SUCCESS; } cleanup: if (pRecord) free(pRecord); return status; }
///////////////////////////////////////////////////////////////////////////// // IConextMenu Functions ///////////////////////////////////////////////////////////////////////////// STDMETHODIMP CShellExt::XMenuExt::QueryContextMenu(HMENU hMenu,UINT indexMenu, UINT idCmdFirst, UINT idCmdLast,UINT uFlags) { METHOD_PROLOGUE(CShellExt, MenuExt); // Don't add any menu items if we're being asked to deal with this file as a shortcut. if (uFlags & CMF_VERBSONLY) return MAKE_HRESULT(SEVERITY_SUCCESS, FACILITY_NULL, (USHORT)0); if (!pThis->m_bIsPathInAFS) return MAKE_HRESULT(SEVERITY_SUCCESS, FACILITY_NULL, (USHORT)0); // Check to see if there's already an AFS menu here; if so, remove it int nItemsNow = GetMenuItemCount (hMenu); CString strAfsItemText = GetMessageString(IDS_AFS_ITEM); CString strDeleteText = GetMessageString(IDS_MENU_DELETE); CString strCutText = GetMessageString(IDS_MENU_CUT); LPCTSTR pszAfsItemText = (LPCTSTR)strAfsItemText; for (int iItem = 0; iItem < nItemsNow; iItem++) { TCHAR szItemText[256]; if (!GetMenuString (hMenu, iItem, szItemText, 256, MF_BYPOSITION)) continue; if (lstrcmp (szItemText, pszAfsItemText)==0) { DeleteMenu (hMenu, iItem, MF_BYPOSITION); continue; } if (((lstrcmp(szItemText,strDeleteText)==0)||(lstrcmp(szItemText,strCutText)==0))&&((pThis->m_bIsSymlink)||(pThis->m_bIsMountpoint))) { DeleteMenu (hMenu, iItem, MF_BYPOSITION); continue; } } int indexShellMenu = 0; // Create the AFS submenu using the allowed ID's. HMENU hAfsMenu = CreatePopupMenu(); int indexAfsMenu = 0; // Only enable the ACL menu item if a single directory is selected int nSingleDirOnly = MF_GRAYED; if (pThis->m_bDirSelected && (pThis->m_astrFileNames.GetSize() == 1)) nSingleDirOnly = MF_ENABLED; ::InsertMenu(hAfsMenu, indexAfsMenu++, MF_STRING | MF_BYPOSITION | nSingleDirOnly, idCmdFirst + IDM_ACL_SET, GetMessageString(IDS_ACLS_ITEM)); // Volume/Partition submenu of the AFS submenu HMENU hVolPartMenu = CreatePopupMenu(); int indexVolPartMenu = 0; ::InsertMenu(hVolPartMenu, indexVolPartMenu++, MF_STRING | MF_BYPOSITION, idCmdFirst + IDM_VOLUME_PROPERTIES, GetMessageString(IDS_VOL_PART_PROPS_ITEM)); ::InsertMenu(hVolPartMenu, indexVolPartMenu++, MF_STRING | MF_BYPOSITION, idCmdFirst + IDM_VOLUMEPARTITION_UPDATENAMEIDTABLE, GetMessageString(IDS_VOL_PART_REFRESH_ITEM)); ::InsertMenu(hAfsMenu, indexAfsMenu++, MF_STRING | MF_BYPOSITION | MF_POPUP, (UINT)hVolPartMenu, GetMessageString(IDS_VOL_PART_ITEM)); // Mount Point submenu of the AFS submenu HMENU hMountPointMenu = CreatePopupMenu(); int indexMountPointMenu = 0; int nMountPointSelected = MF_GRAYED; for (int n = pThis->m_astrFileNames.GetSize() - 1 ; n >= 0; n--) { if ( IsMountPoint(pThis->m_astrFileNames[n]) ) { nMountPointSelected = MF_ENABLED; break; } } ::InsertMenu(hMountPointMenu, indexMountPointMenu++, MF_STRING | MF_BYPOSITION, idCmdFirst + IDM_MOUNTPOINT_SHOW, GetMessageString(IDS_MP_SHOW_ITEM)); ::InsertMenu(hMountPointMenu, indexMountPointMenu++, MF_STRING | MF_BYPOSITION | nMountPointSelected, idCmdFirst + IDM_MOUNTPOINT_REMOVE, GetMessageString(IDS_MP_REMOVE_ITEM)); ::InsertMenu(hMountPointMenu, indexMountPointMenu++, MF_STRING | MF_BYPOSITION, idCmdFirst + IDM_MOUNTPOINT_MAKE, GetMessageString(IDS_MP_MAKE_ITEM)); ::InsertMenu(hAfsMenu, indexAfsMenu++, MF_STRING | MF_BYPOSITION | MF_POPUP, (UINT)hMountPointMenu, GetMessageString(IDS_MOUNT_POINT_ITEM)); ::InsertMenu(hAfsMenu, indexAfsMenu++, MF_STRING | MF_BYPOSITION, idCmdFirst + IDM_FLUSH, GetMessageString(IDS_FLUSH_FILE_DIR_ITEM)); ::InsertMenu(hAfsMenu, indexAfsMenu++, MF_STRING | MF_BYPOSITION, idCmdFirst + IDM_FLUSH_VOLUME, GetMessageString(IDS_FLUSH_VOLUME_ITEM)); ::InsertMenu(hAfsMenu, indexAfsMenu++, MF_STRING | MF_BYPOSITION, idCmdFirst + IDM_SHOW_SERVER, GetMessageString(IDS_SHOW_FILE_SERVERS_ITEM)); ::InsertMenu(hAfsMenu, indexAfsMenu++, MF_STRING | MF_BYPOSITION, idCmdFirst + IDM_SHOWCELL, GetMessageString(IDS_SHOW_CELL_ITEM)); ::InsertMenu(hAfsMenu, indexAfsMenu++, MF_STRING | MF_BYPOSITION, idCmdFirst + IDM_SERVER_STATUS, GetMessageString(IDS_SHOW_SERVER_STATUS_ITEM)); HMENU hSymbolicMenu = CreatePopupMenu(); int indexSymbolicMenu = 0; int nSymlinkSelected = MF_GRAYED; for (int n = pThis->m_astrFileNames.GetSize() - 1 ; n >= 0; n--) { if ( IsSymlink(pThis->m_astrFileNames[n]) ) { nSymlinkSelected = MF_ENABLED; break; } } ::InsertMenu(hSymbolicMenu, indexSymbolicMenu++, MF_STRING | MF_BYPOSITION, idCmdFirst + IDM_SYMBOLICLINK_ADD, GetMessageString(IDS_SYMBOLICLINK_ADD)); ::InsertMenu(hSymbolicMenu, indexSymbolicMenu++, MF_STRING | MF_BYPOSITION | nSymlinkSelected, idCmdFirst + IDM_SYMBOLICLINK_SHOW, GetMessageString(IDS_SYMBOLICLINK_SHOW)); ::InsertMenu(hSymbolicMenu, indexSymbolicMenu++, MF_STRING | MF_BYPOSITION | nSymlinkSelected, idCmdFirst + IDM_SYMBOLICLINK_REMOVE, GetMessageString(IDS_SYMBOLICLINK_REMOVE)); ::InsertMenu(hAfsMenu, indexAfsMenu++, MF_STRING | MF_BYPOSITION | MF_POPUP, (UINT)hSymbolicMenu, GetMessageString(IDS_SYMBOLIC_LINK_ITEM)); // The Submounts menu has been removed because the AFS tray icon // and control panel now support mapping drives directly to an AFS // path. // //HMENU hSubmountMenu = CreatePopupMenu(); //int indexSubmountMenu = 0; //::InsertMenu(hSubmountMenu, indexSubmountMenu++, MF_STRING | MF_BYPOSITION | nSingleDirOnly, idCmdFirst + IDM_SUBMOUNTS_CREATE, GetMessageString(IDS_SUBMOUNTS_CREATE_ITEM)); //::InsertMenu(hSubmountMenu, indexSubmountMenu++, MF_STRING | MF_BYPOSITION, idCmdFirst + IDM_SUBMOUNTS_EDIT, GetMessageString(IDS_SUBMOUNTS_EDIT_ITEM)); //::InsertMenu(hAfsMenu, indexAfsMenu++, MF_STRING | MF_BYPOSITION | MF_POPUP, (UINT)hSubmountMenu, GetMessageString(IDS_SUBMOUNTS_ITEM)); // Add a separator ::InsertMenu (hMenu, indexMenu + indexShellMenu++, MF_STRING | MF_BYPOSITION | MF_SEPARATOR, 0, TEXT("")); // Add the AFS submenu to the shell's menu ::InsertMenu(hMenu, indexMenu + indexShellMenu++, MF_STRING | MF_BYPOSITION | MF_POPUP, (UINT)hAfsMenu, GetMessageString(IDS_AFS_ITEM)); // Add a separator after us ::InsertMenu (hMenu, indexMenu + indexShellMenu++, MF_STRING | MF_BYPOSITION | MF_SEPARATOR, 0, TEXT("")); return MAKE_HRESULT(SEVERITY_SUCCESS, FACILITY_NULL, (USHORT)indexAfsMenu + indexVolPartMenu + indexMountPointMenu + indexShellMenu + indexSymbolicMenu); }
/** * @brief Generates a message string about DialogLayoutException. * @retval true processed. * @retval false not processed. */ bool ExceptionMessageGenerator::processDialogLayoutException(Exception* ex, MBCString& message) const { DialogLayoutException* myException = dynamic_cast<DialogLayoutException*>(ex); if (NULL == myException) { return false; } bool resolved = false; // DialogLayoutExceptions::FailedToCompute if (!resolved) { DialogLayoutExceptions::FailedToCompute* myExceptionFTC = dynamic_cast<DialogLayoutExceptions::FailedToCompute*>(ex); if (NULL != myExceptionFTC) { ConstAStr arrow = ALITERAL(" -> "); MBCString leafMessage; MBCString itemName = myExceptionFTC->GetItemName(); MBCString itemRefPath; MBCString itemRefPathLine = itemName; Exception* iex = myExceptionFTC->GetInnerException(); while (NULL != iex) { DialogLayoutExceptions::FailedToCompute* ftcInner = dynamic_cast<DialogLayoutExceptions::FailedToCompute*>(iex); if (NULL != ftcInner) { itemRefPathLine += arrow; MBCString innerItemName = ftcInner->GetItemName(); if (itemRefPathLine.Length() + innerItemName.Length() >= 80) { itemRefPath += itemRefPathLine; itemRefPathLine = ALITERAL("\n "); } itemRefPathLine += innerItemName; iex = ftcInner->GetInnerException(); } else { GetMessageString(iex, leafMessage); break; } } itemRefPath += itemRefPathLine; MessageFormatter::Format(message, stringLoader->LoadNativeString(NSID_EMSG_DIALOG_LAYOUT_COMPUTE), itemName.CString(), leafMessage.CString(), itemRefPath.CString()); resolved = true; } } // DialogLayoutExceptions::ItemNotFound if (!resolved) { DialogLayoutExceptions::ItemNotFound* myExceptionINF = dynamic_cast<DialogLayoutExceptions::ItemNotFound*>(ex); if (NULL != myExceptionINF) { MessageFormatter::Format(message, stringLoader->LoadNativeString(NSID_EMSG_DIALOG_LAYOUT_NOT_FOUND), myExceptionINF->GetItemName().CString()); resolved = true; } } // DialogLayoutExceptions::CircularReference if (!resolved) { DialogLayoutExceptions::CircularReference* myExceptionCR = dynamic_cast<DialogLayoutExceptions::CircularReference*>(ex); if (NULL != myExceptionCR) { message = stringLoader->LoadNativeString(NSID_EMSG_DIALOG_LAYOUT_CIRCULAR_REF); resolved = true; } } // DialogLayoutExceptions::ItemNotComputed if (!resolved) { // This must be a bug of the application. It must not be occured in end-user environment. } return true; }
/* Process a given event */ DWORD ProcessEvent(EVT_HANDLE hEvent) { EVT_HANDLE hProviderMetadata = NULL; PEVT_VARIANT eventInfo = NULL; LPWSTR pwsMessage = NULL; LPWSTR pwszPublisherName = NULL; ULONGLONG eventTime; ULONGLONG keyword; DWORD status = ERROR_SUCCESS; int event_id = 0; int winlevel = 0; int level = 0; WCHAR source[SOURCE_SZ]; WCHAR hostname[HOSTNAME_SZ]; WCHAR * formatted_string = NULL; WCHAR * tstamp = NULL; WCHAR * index = NULL; WCHAR defmsg[ERRMSG_SZ]; WCHAR tstamped_message[SYSLOG_DEF_SZ]; /* Get and store the publishers new Windows Events name */ eventInfo = GetEventInfo(hEvent); if (eventInfo) { pwszPublisherName = (LPWSTR)eventInfo[0].StringVal; } else { return ERR_CONTINUE; } eventTime = eventInfo[1].FileTimeVal; event_id = eventInfo[2].UInt16Val; /* Check for the "Microsoft-Windows-" prefix in the publisher name */ /* and remove it if found. Saves 18 characters in the message */ if(wcsncmp(pwszPublisherName, L"Microsoft-Windows-", 18) == 0) wcsncpy_s(source, COUNT_OF(source), pwszPublisherName+18, _TRUNCATE); else wcsncpy_s(source, COUNT_OF(source), pwszPublisherName, _TRUNCATE); /* Format Event Timestamp */ if ((tstamp = WinEventTimeToString(eventTime)) == NULL) tstamp = L"TIME_ERROR"; /* Add hostname for RFC compliance (RFC 3164) */ if (ProgramUseIPAddress == TRUE) { _snwprintf_s(hostname, HOSTNAME_SZ, _TRUNCATE, L"%S", ProgramHostName); } else { if (ExpandEnvironmentStringsW(L"%COMPUTERNAME%", hostname, COUNT_OF(hostname)) == 0) { wcscpy_s(hostname, COUNT_OF(hostname), L"HOSTNAME_ERR"); Log(LOG_ERROR|LOG_SYS, "Cannot expand %COMPUTERNAME%"); } } /* replace every space in source by underscores */ index = source; while( *index ) { if( *index == L' ' ) { *index = L'_'; } index++; } /* Add Timestamp and hostname then format source & event ID for consistency with Event Viewer */ if(SyslogIncludeTag) { _snwprintf_s(tstamped_message, COUNT_OF(tstamped_message), _TRUNCATE, L"%s %s %S: %s: %i: ", tstamp, hostname, SyslogTag, source, event_id ); } else { _snwprintf_s(tstamped_message, COUNT_OF(tstamped_message), _TRUNCATE, L"%s %s %s: %i: ", tstamp, hostname, source, event_id ); } /* Get the handle to the provider's metadata that contains the message strings. */ hProviderMetadata = EvtOpenPublisherMetadata(NULL, pwszPublisherName, NULL, 0, 0); if (NULL == hProviderMetadata) { if (LogInteractive) Log(LOG_ERROR|LOG_SYS, "OpenPublisherMetadata failed for Publisher: \"%S\"", source); return ERR_CONTINUE; } /* Get the message string from the event */ pwsMessage = GetMessageString(hProviderMetadata, hEvent); if (pwsMessage == NULL) { Log(LOG_ERROR|LOG_SYS, "Error getting message string for event DETAILS: Publisher: %S EventID: %i", source, event_id); return ERR_CONTINUE; } /* Get string and strip whitespace */ formatted_string = CollapseExpandMessageW(pwsMessage); /* Create a default message if resources or formatting didn't work */ if (formatted_string == NULL) { if(SyslogIncludeTag) { _snwprintf_s(defmsg, COUNT_OF(defmsg), _TRUNCATE, L"%S: (Facility: %u, Status: %s)", SyslogTag, HRESULT_FACILITY(event_id), FAILED(event_id) ? L"Failure" : L"Success" ); } else { _snwprintf_s(defmsg, COUNT_OF(defmsg), _TRUNCATE, L"(Facility: %u, Status: %s)", HRESULT_FACILITY(event_id), FAILED(event_id) ? L"Failure" : L"Success" ); } formatted_string = defmsg; } /* Get Event Error Level. In the case of Security Events, * set Failures to Error instead of notice using the * keyword attribute */ keyword = (EvtVarTypeNull == eventInfo[4].Type) ? 0 : eventInfo[4].UInt64Val; if ((keyword & WINEVENT_KEYWORD_AUDIT_FAILURE) != 0) { // Add AUDIT_FAILURE message for better parsing wcsncat_s(tstamped_message, COUNT_OF(tstamped_message), L"AUDIT_FAILURE ", _TRUNCATE); winlevel = WINEVENT_ERROR_LEVEL; } else winlevel = (int)eventInfo[3].ByteVal; /* Select syslog level */ switch (winlevel) { case WINEVENT_CRITICAL_LEVEL: level = SYSLOG_BUILD(SyslogFacility, SYSLOG_CRIT); break; case WINEVENT_ERROR_LEVEL: level = SYSLOG_BUILD(SyslogFacility, SYSLOG_ERR); break; case WINEVENT_WARNING_LEVEL: level = SYSLOG_BUILD(SyslogFacility, SYSLOG_WARNING); break; case WINEVENT_INFORMATION_LEVEL: level = SYSLOG_BUILD(SyslogFacility, SYSLOG_NOTICE); break; case WINEVENT_AUDIT_LEVEL: wcsncat_s(tstamped_message, COUNT_OF(tstamped_message), L"AUDIT_SUCCESS ", _TRUNCATE); level = SYSLOG_BUILD(SyslogFacility, SYSLOG_NOTICE); break; case WINEVENT_VERBOSE_LEVEL: level = SYSLOG_BUILD(SyslogFacility, SYSLOG_DEBUG); break; /* Everything else */ default: level = SYSLOG_BUILD(SyslogFacility, SYSLOG_NOTICE); break; } /* Combine the message strings */ wcsncat_s(tstamped_message, COUNT_OF(tstamped_message), formatted_string, _TRUNCATE); /* Send the event to the Syslog Server */ /* Making sure it is severe enough to be logged */ if (SyslogLogLevel == 0 || (SyslogLogLevel >= (DWORD)winlevel && winlevel > 0)) if (SyslogSendW(tstamped_message, level)) status = ERR_FAIL; /* Cleanup memory and open handles */ if(pwsMessage) free(pwsMessage); if(eventInfo) free(eventInfo); if (hProviderMetadata) EvtClose(hProviderMetadata); if (hEvent) EvtClose(hEvent); return status; }
/** * @brief Enumerate all the events in the result set. * @param eventHandle A handle to an event. * * @return returns Print event status. */ DWORD EventLogReader::PrintEvent(EVT_HANDLE eventHandle) { EVT_HANDLE context = nullptr; PEVT_VARIANT renderedValues = nullptr; DWORD status = ERROR_SUCCESS; do { // Identify the components of the event that you want to render. In this case, // render the system section of the event. context = EvtCreateRenderContext(0, nullptr, EvtRenderContextSystem); if (context == nullptr) { status = GetLastError(); break; } // When you render the user data or system section of the event, you must specify // the EvtRenderEventValues flag. The function returns an array of variant values // for each element in the user data or system section of the event. For user data // or event data, the values are returned in the same order as the elements are // defined in the event. For system data, the values are returned in the order defined // in the EVT_SYSTEM_PROPERTY_ID enumeration. DWORD bufferSize = 0; DWORD bufferUsed = 0; DWORD propertyCount = 0; if (!EvtRender(context, eventHandle, EvtRenderEventValues, bufferSize, renderedValues, &bufferUsed, &propertyCount)) { status = GetLastError(); if (status == ERROR_INSUFFICIENT_BUFFER) { bufferSize = bufferUsed; renderedValues = (PEVT_VARIANT)malloc(bufferSize); if (renderedValues != nullptr) { EvtRender(context, eventHandle, EvtRenderEventValues, bufferSize, renderedValues, &bufferUsed, &propertyCount); status = GetLastError(); } else { status = ERROR_OUTOFMEMORY; break; } } if (status != ERROR_SUCCESS) break; } std::map<std::string, std::string> eventData; std::wstring tempBuf = (renderedValues[EvtSystemProviderName].StringVal) ? renderedValues[EvtSystemProviderName].StringVal : L""; eventData["providername"] = base::wstring_to_string(tempBuf); if (renderedValues[EvtSystemProviderGuid].GuidVal != nullptr) { WCHAR guid[50] = {0}; StringFromGUID2(*(renderedValues[EvtSystemProviderGuid].GuidVal), guid, sizeof(guid) / sizeof(WCHAR)); eventData["providerguid"] = base::wstring_to_string(guid); } DWORD eventId = renderedValues[EvtSystemEventID].UInt16Val; if (renderedValues[EvtSystemQualifiers].Type == EvtVarTypeNull) eventId = MAKELONG(renderedValues[EvtSystemEventID].UInt16Val, renderedValues[EvtSystemQualifiers].UInt16Val); char buf[1024] = { 0 }; snprintf(buf, sizeof(buf), "%lu", eventId); eventData["eventid"] = buf; snprintf(buf, sizeof(buf), "%u", (renderedValues[EvtSystemVersion].Type == EvtVarTypeNull) ? 0 : renderedValues[EvtSystemVersion].ByteVal); eventData["version"] = buf; snprintf(buf, sizeof(buf), "%u", (renderedValues[EvtSystemLevel].Type == EvtVarTypeNull) ? 0 : renderedValues[EvtSystemLevel].ByteVal); eventData["level"] = buf; snprintf(buf, sizeof(buf), "%hu", (renderedValues[EvtSystemTask].Type == EvtVarTypeNull) ? 0 : renderedValues[EvtSystemTask].ByteVal); eventData["task"] = buf; snprintf(buf, sizeof(buf), "%u", (renderedValues[EvtSystemOpcode].Type == EvtVarTypeNull) ? 0 : renderedValues[EvtSystemOpcode].UInt16Val); eventData["opcode"] = buf; snprintf(buf, sizeof(buf), "%0x%I64x", (renderedValues[EvtSystemKeywords].Type == EvtVarTypeNull) ? 0 : renderedValues[EvtSystemOpcode].UInt64Val); eventData["keywords"] = buf; ULONGLONG ullTimeStamp = renderedValues[EvtSystemTimeCreated].FileTimeVal; FILETIME ft; ft.dwHighDateTime = (DWORD)((ullTimeStamp >> 32) & 0xFFFFFFFF); ft.dwLowDateTime = (DWORD)(ullTimeStamp & 0xFFFFFFFF); SYSTEMTIME st; FileTimeToSystemTime(&ft, &st); ULONGLONG ullNanoseconds = (ullTimeStamp % 10000000) * 100; // Display nanoseconds instead of milliseconds for higher resolution snprintf(buf, sizeof(buf), "%02d/%02d/%02d %02d:%02d:%02d.%I64u", st.wMonth, st.wDay, st.wYear, st.wHour, st.wMinute, st.wSecond, ullNanoseconds); eventData["timecreated"] = buf; snprintf(buf, sizeof(buf), "%I64u", renderedValues[EvtSystemEventRecordId].UInt64Val); eventData["eventrecordid"] = buf; if (renderedValues[EvtSystemActivityID].Type != EvtVarTypeNull) { WCHAR guid[50] = { 0 }; StringFromGUID2(*(renderedValues[EvtSystemActivityID].GuidVal), guid, sizeof(guid) / sizeof(WCHAR));; eventData["activityid"] = base::wstring_to_string(guid); } if (renderedValues[EvtSystemRelatedActivityID].Type != EvtVarTypeNull) { WCHAR guid[50] = { 0 }; StringFromGUID2(*(renderedValues[EvtSystemRelatedActivityID].GuidVal), guid, sizeof(guid) / sizeof(WCHAR));; eventData["relatedactivityid"] = base::wstring_to_string(guid); } snprintf(buf, sizeof(buf), "%lu", renderedValues[EvtSystemProcessID].UInt32Val); eventData["processid"] = buf; snprintf(buf, sizeof(buf), "%lu", renderedValues[EvtSystemThreadID].UInt32Val); eventData["threadid"] = buf; tempBuf = (renderedValues[EvtSystemChannel].Type == EvtVarTypeNull) ? renderedValues[EvtSystemChannel].StringVal : L""; eventData["channel"] = base::wstring_to_string(tempBuf); eventData["computer"] = base::wstring_to_string(renderedValues[EvtSystemComputer].StringVal); if (renderedValues[EvtSystemUserID].Type != EvtVarTypeNull) { LPWSTR pwsSid = nullptr; if (ConvertSidToStringSid(renderedValues[EvtSystemUserID].SidVal, &pwsSid)) { eventData["secuserid"] = base::wstring_to_string(pwsSid); LocalFree(pwsSid); } } // Get the handle to the provider's metadata that contains the message strings. EVT_HANDLE providerMetadata = EvtOpenPublisherMetadata(nullptr, renderedValues[EvtSystemProviderName].StringVal, nullptr, 0, 0); if (providerMetadata == nullptr) break; eventData["message"] = GetMessageString(providerMetadata, eventHandle); _printResultsCallback(eventData); } while (false); if (context) EvtClose(context); if (renderedValues) free(renderedValues); return status; }
void DrawInputBar(InputWindow* inputWindow, int iCursorPos, Messages * msgup, Messages *msgdown ,unsigned int * iheight, unsigned int *iwidth) { int i; char *strUp[MAX_MESSAGE_COUNT]; char *strDown[MAX_MESSAGE_COUNT]; int posUpX[MAX_MESSAGE_COUNT], posUpY[MAX_MESSAGE_COUNT]; int posDownX[MAX_MESSAGE_COUNT], posDownY[MAX_MESSAGE_COUNT]; int oldHeight = *iheight, oldWidth = *iwidth; int newHeight = 0, newWidth = 0; int cursor_pos=0; int inputWidth = 0, outputWidth = 0; int outputHeight = 0; FcitxInputState* input = &inputWindow->owner->owner->input; FcitxInstance* instance = inputWindow->owner->owner; int iChar = iCursorPos; int strWidth = 0, strHeight = 0; int fontSize = FONTHEIGHT; if (!IsMessageChanged(msgup) && !IsMessageChanged(msgdown)) return; inputWidth = 0; strHeight = FONTHEIGHT; for (i = 0; i < GetMessageCount(msgup) ; i++) { char *trans = ProcessOutputFilter(instance, GetMessageString(msgup, i)); if (trans) strUp[i] = trans; else strUp[i] = GetMessageString(msgup, i); posUpX[i] = MarginLeft + inputWidth; strWidth = StringWidth(inputWindow->dpy, inputWindow->owner->xftfont, strUp[i]); posUpY[i] = MarginTop + InputPos - strHeight; inputWidth += strWidth; if (input->bShowCursor) { int length = strlen(GetMessageString(msgup, i)); if (iChar >= 0) { if (iChar < length) { char strTemp[MESSAGE_MAX_LENGTH]; char *strGBKT = NULL; strncpy(strTemp, strUp[i], iChar); strTemp[iChar] = '\0'; strGBKT = strTemp; strWidth = StringWidth(inputWindow->dpy, inputWindow->owner->xftfont, strGBKT); cursor_pos= posUpX[i] + strWidth + 2; } iChar -= length; } } } if (iChar >= 0) cursor_pos = inputWidth + MarginLeft; outputWidth = 0; outputHeight = 0; int currentX = 0; for (i = 0; i < GetMessageCount(msgdown) ; i++) { char *trans = ProcessOutputFilter(instance, GetMessageString(msgdown, i)); if (trans) strDown[i] = trans; else strDown[i] = GetMessageString(msgdown, i); if (inputWindow->owner->bVerticalList) /* vertical */ { if (GetMessageType(msgdown, i) == MSG_INDEX) { if (currentX > outputWidth) outputWidth = currentX; if (i != 0) { outputHeight += fontSize + 2; currentX = 0; } } posDownX[i] = MarginLeft + currentX; strWidth = StringWidth(inputWindow->dpy, inputWindow->owner->xftfont, strDown[i]); currentX += strWidth; posDownY[i] = MarginTop + OutputPos + outputHeight - strHeight; } else /* horizontal */ { posDownX[i] = MarginLeft + outputWidth; strWidth = StringWidth(inputWindow->dpy, inputWindow->owner->xftfont, strDown[i]); posDownY[i] = MarginTop + OutputPos - strHeight; outputWidth += strWidth; } } if (inputWindow->owner->bVerticalList && currentX > outputWidth) outputWidth = currentX; newHeight = MarginTop + OutputPos + outputHeight + MarginBottom; newWidth = (inputWidth<outputWidth)?outputWidth:inputWidth; newWidth+=MarginLeft+MarginRight; /* round to ROUND_SIZE in order to decrease resize */ newWidth = (newWidth / ROUND_SIZE) * ROUND_SIZE + ROUND_SIZE; //输入条长度应该比背景图长度要长,比最大长度要短 newWidth=(newWidth>=INPUT_BAR_MAX_WIDTH)?INPUT_BAR_MAX_WIDTH:newWidth; if (inputWindow->owner->bVerticalList) /* vertical */ { newWidth = (newWidth < INPUT_BAR_VMIN_WIDTH)?INPUT_BAR_VMIN_WIDTH:newWidth; } else { newWidth = (newWidth < INPUT_BAR_HMIN_WIDTH)?INPUT_BAR_HMIN_WIDTH:newWidth; } *iwidth = newWidth; *iheight = newHeight; if (oldHeight != newHeight || oldWidth != newWidth) { DrawResizableBackground(inputWindow->owner, inputWindow->pixmap2, newHeight, newWidth, inputWindow->owner->backcolor, inputWindow->owner->bordercolor, inputWindow->pixmap2_gc ); } XGCValues gcvalues; GC gc = XCreateGC(inputWindow->dpy, inputWindow->pixmap, 0, &gcvalues); XCopyArea( inputWindow->dpy, inputWindow->pixmap2, inputWindow->pixmap, gc, 0, 0, inputWindow->iInputWindowWidth, inputWindow->iInputWindowHeight, 0, 0 ); XFreeGC(inputWindow->dpy, gc); if (input->bShowCursor ) { //画向前向后箭头 } for (i = 0; i < GetMessageCount(msgup) ; i++) { OutputString(inputWindow->dpy, inputWindow->xftDraw, inputWindow->pixmap, inputWindow->owner->xftfont, strUp[i], posUpX[i], posUpY[i], inputWindow->owner->fontColor[GetMessageType(msgup, i)]); if (strUp[i] != GetMessageString(msgup, i)) free(strUp[i]); } for (i = 0; i < GetMessageCount(msgdown) ; i++) { OutputString(inputWindow->dpy, inputWindow->xftDraw, inputWindow->pixmap, inputWindow->owner->xftfont, strDown[i], posDownX[i], posDownY[i], inputWindow->owner->fontColor[GetMessageType(msgdown, i)]); if (strDown[i] != GetMessageString(msgdown, i)) free(strDown[i]); } //画光标 if (input->bShowCursor ) { GC gc = LightUICreateGC(inputWindow->dpy, inputWindow->pixmap, inputWindow->owner->cursorColor); XDrawLine(inputWindow->dpy, inputWindow->pixmap, gc, cursor_pos, MarginTop + InputPos, cursor_pos, MarginTop + InputPos - fontSize - 4); XFreeGC(inputWindow->dpy, gc); } SetMessageChanged(msgup, false); SetMessageChanged(msgdown, false); }
int main( int argc, char *argv[] ) { struct event *eventptr; struct msg msg2give; struct pkt pkt2give; int currentEntity; int i,j; // Do our initialization and any requested by student's Transport Layer CallingArgc = argc; CallingArgv = argv; init( ); A_init(); B_init(); /* *********************************************************************** We loop here forever. During these actions we get an event off the event header. We analyze the action to be performed and go do it. *************************************************************************/ while (TRUE) { eventptr = evlist; // get next event to simulate from Q head if (eventptr==NULL) // IF nothing to simulate, we're done break; evlist = evlist->next; // remove this event from event list if (evlist != NULL) // and sort out forward and back ptrs evlist->prev=NULL; // Update simulation time to event time - by definition, the // simulation time is the time of the last event. CurrentSimTime = eventptr->evtime; currentEntity = eventptr->eventity; // If we've delivered the required number of messages, then we've // fullfilled our task and are done. if ( NumMsgs4To5 >= MaxMsgsToSimulate ) break; // all done with simulation /* ******************************************************************* Here we've gotten a request to hand data from layer 5 to layer 4. Generate the date we want to give to the student. *********************************************************************/ if ( eventptr->evtype == FROM_LAYER5 ) { // Use the sequence number as starter for the message string j = GeneratingSeqNum[currentEntity]++; // printf( "%X %d %d\n", &eventptr, currentEntity, j ); GetMessageString( currentEntity, j, &(msg2give.data[0]) ); /* Always print trace so we know it matches the receive */ if ( TraceLevel >= 0 ) { //printf("%c: ", &(EntityLetter[currentEntity]) ); if ( currentEntity == AEntity ) printf("A: " ); else printf("B: " ); printf(" %11.4f,", eventptr->evtime); printf(" Layer 5 to 4 Message = "); for (i=0; i<MESSAGE_LENGTH; i++) printf("%c", msg2give.data[i]); printf("\n"); } // The simulation will actually end when the requested number of // messages has been received back at layer 5. But there could be // many packets in the system, and that total arrival could take // a long time. We want to make sure we down't overwhelm the // student code with messages that won't ever be delivered anyway. // if ( NumMsgs5To4 <= MaxMsgsToSimulate + 3 ) { GenerateNextArrival(); // set up future arrival NumMsgs5To4++; // # msgs from layer 5 to 4 } if ( currentEntity == AEntity ) // Pass the data to layer 4 here A_output(msg2give); else B_output(msg2give); } /* END of event is from layer 5 */ /* ******************************************************************* This is a request to hand data from layer 3 up to student layer 4 *********************************************************************/ else if (eventptr->evtype == FROM_LAYER3 ) { pkt2give.seqnum = eventptr->pktptr->seqnum; pkt2give.acknum = eventptr->pktptr->acknum; pkt2give.checksum = eventptr->pktptr->checksum; for ( i = 0; i < MESSAGE_LENGTH; i++) pkt2give.payload[i] = eventptr->pktptr->payload[i]; if ( TraceLevel >= 2 ) { /* Print out trace info if requested */ if ( eventptr->eventity == AEntity ) printf("A: " ); else printf("B: " ); printf(" %11.4f,", eventptr->evtime); printf(" Layer 3 to 4 "); printf( "Seq/Ack/Check = %d/%d/%d: ", eventptr->pktptr->seqnum, eventptr->pktptr->acknum, eventptr->pktptr->checksum ); for (i=0; i<MESSAGE_LENGTH; i++) printf("%c", eventptr->pktptr->payload[i] ); printf("\n"); } if (eventptr->eventity == AEntity) /* deliver packet by calling */ A_input(pkt2give); /* appropriate entity */ else B_input(pkt2give); free(eventptr->pktptr); /* free the memory for packet */ } /* END of event is from layer 3 */ /* ******************************************************************* This is a request for a timer interrupt *********************************************************************/ else if (eventptr->evtype == TIMER_INTERRUPT) { if ( TraceLevel >= 2 ) { /* Print out trace info if requested */ if ( eventptr->eventity == AEntity ) printf("A: " ); else printf("B: " ); printf(" %f,", eventptr->evtime); printf(" Timer Interrupt\n"); } if (eventptr->eventity == AEntity) A_timerinterrupt(); else B_timerinterrupt(); } /* END of event is interrupt request */ else { printf("INTERNAL PANIC: unknown event type \n"); } free(eventptr); } // End of while terminate: printf("\n\nSimulator terminated at time %f\n after receiving %d msgs at layer5\n", CurrentSimTime, NumMsgs4To5 ); printf( "Simulator Analysis:\n"); printf( " Number of messages sent from 5 to 4: %d\n", NumMsgs5To4 ); printf( " Number of messages received at Layer 5, side A: %d\n", ExpectedSeqNum[0] ); printf( " Number of messages received at Layer 5, side B: %d\n", ExpectedSeqNum[1] ); printf( " Number of messages incorrectly received at layer 5: %d\n", NumMsgs5To4WithErr ); printf( " Number of packets entering the network: %d\n", NumMsgs4To3 ); printf( " Average number of packets already in network: %6.3f\n", (double)NumSimutaneousMsgs / (double)NumMsgs4To3 ); printf( " Number of packets that the network lost: %d\n", NumMsgsLost ); printf( " Number of packets that the network corrupted: %d\n", NumMsgsCorrupt ); printf( " Number of packets that the network put out of order: %d\n", NumMsgsOutOfOrder ); return 0; }