Список использованных источников
1 Харт Джонсон. Системное программирование в среде Windows AnyLogic / Харт Джонсон /. – Москва, 2005. – 592с.
2 Саймон Ричардс. Microsoft Windows API Справочник системного программиста/ Саймон Ричардс // М.: Подробное руководство.–Спб, 2014 – 1216 с.
3 Пол Мак-Федрис. Microsoft Windows 7 Unleashed: Подробное руководство/ Пол Мак-Федрис.; Вильямс. – Москва, 2012. – 800 с.
4 Пенкрат, Л.М. Программирование аппаратных средств в Windows / Л.М. Пенкрат// М.: профессиональное программирование.–Спб, 2008 – 528 с.
5 Сбор информации о компьютере [Электронный ресурс]. – 2017. – Режим доступа: http://sysadminblog.ru/code/2011/03/01/c-sbor-informacii-o-kompyutere-2.html – Дата доступа: 24.09.2017.
6 Программирование на C, C# и Java [Электронный ресурс]. – 2017. – Режим доступа: http://vscode.ru/prog-lessons/get-comp-info-wmi.html – Дата доступа: 04.11.2017.
7 Получение информации о ПК [Электронный ресурс]. – 2017. – Режим доступа: http://www.cyberforum.ru/csharp-net/thread254777.html – Дата доступа: 17.11.2017.
Приложение А
Файл kurs . cpp
#include <stdio.h>
#include <tchar.h>
#include <windows.h>
#include <winioctl.h>
#include <stdlib.h>
#include <winsock2.h>
#include <tlhelp32.h>
#include <iphlpapi.h>
#include <Commdlg.h>
#include<Winsock2.h>
#pragma comment(lib, "Ws2_32.lib")
#pragma comment(lib, "iphlpapi.lib")
#define MALLOC(x) HeapAlloc(GetProcessHeap(), 0, (x))
#define FREE(x) HeapFree(GetProcessHeap(), 0, (x))
#define MAX_LOADSTRING 100
#define MAX_RECORD_BUFFER_SIZE 0x10000
#define MAX_TIMESTAMP_LEN 23 + 1 // mm/dd/yyyy hh:mm:ss.mmm
// Идентификаторы кнопок и окна редактирования
#define MAX_LOADSTRING 100
#define ID_BUTTON_1 3000
#define ID_BUTTON_2 3001
#define ID_BUTTON_3 3002
|
|
|
#define ID_BUTTON_4 3003
#define ID_BUTTON_5 3004
#define ID_BUTTON_6 3005
#define ID_BUTTON_7 3006
#define ID_BUTTON_8 3007
#define ID_BUTTON_9 3009
#define ID_BUTTON_10 3010
#define ID_BUTTON_11 3011
#define ID_BUTTON_12 3012
#define ID_BUTTON_13 3013
#define ID_BUTTON_14 3014
#define ID_EDIT 3008
typedef BOOL (WINAPI *PFUNC)(LPCSTR, DWORD, PDISPLAY_DEVICE, DWORD);
// Глобальные переменные
HINSTANCE hInst;
TCHAR szTitle[MAX_LOADSTRING]; // Заголовок
TCHAR szWindowClass[MAX_LOADSTRING]; // Клас окна
char cBuffer[MAX_RECORD_BUFFER_SIZE];
HWND hBtn1; // Кнопки
HWND hBtn2;
HWND hBtn3;
HWND hBtn4;
HWND hBtn5;
HWND hBtn6;
HWND hBtn7;
HWND hBtn8;
HWND hBtn9;
HWND hBtn10;
HWND hBtn11;
HWND hBtn12;
HWND hBtn13;
HWND hBtn14;
HWND hwndEdit; // Окно с информацией
ATOM MyRegisterClass(HINSTANCE hInstance);
BOOL InitInstance(HINSTANCE, int);
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK About(HWND, UINT, WPARAM, LPARAM);
int APIENTRY WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow)
{
MSG msg;
// Загружаем строки
LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
LoadString(hInstance, IDC_KURS, szWindowClass, MAX_LOADSTRING);
// Регистрируем класс окна
MyRegisterClass(hInstance);
if (!InitInstance (hInstance, nCmdShow))
{
return FALSE;
}
// Цикл обработки сообщений
|
|
|
while (GetMessage(&msg, NULL, 0, 0))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
return msg.wParam;
}
// Регистрируем класс окна
ATOM MyRegisterClass(HINSTANCE hInstance)
{
WNDCLASSEX wcex;
wcex.cbSize = sizeof(WNDCLASSEX);
wcex.style = CS_HREDRAW | CS_VREDRAW;
wcex.lpfnWndProc = (WNDPROC)WndProc;
wcex.cbClsExtra = 0;
wcex.cbWndExtra = 0;
wcex.hInstance = hInstance;
wcex.hIcon = LoadIcon(hInstance, (LPCTSTR)IDI_KURS);
wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
wcex.lpszMenuName = (LPCSTR)IDC_KURS;
wcex.lpszClassName = szWindowClass;
wcex.hIconSm = LoadIcon(wcex.hInstance, (LPCTSTR)IDI_SMALL);
return RegisterClassEx(&wcex);
}
// Инициализация приложения
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
HWND hWnd;
hInst = hInstance;
// Создаем окно
hWnd = CreateWindow(szWindowClass, "Курсовая работа", WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);
if (!hWnd)
{
return FALSE;
}
//Создаем кнопки на основном окне
hBtn1 = CreateWindow("BUTTON", "Процессор", BS_PUSHBUTTON | WS_VISIBLE | WS_CHILD | WS_TABSTOP, 10, 25, 200, 30, hWnd, (HMENU)ID_BUTTON_1, hInstance, NULL);
hBtn2 = CreateWindow("BUTTON", "BIOS", BS_PUSHBUTTON | WS_VISIBLE | WS_CHILD | WS_TABSTOP, 10, 65, 200, 30, hWnd, (HMENU)ID_BUTTON_2, hInstance, NULL);
hBtn3 = CreateWindow("BUTTON", "Разделы HDD", BS_PUSHBUTTON | WS_VISIBLE | WS_CHILD | WS_TABSTOP, 10, 105, 200, 30, hWnd, (HMENU)ID_BUTTON_3, hInstance, NULL);
hBtn4 = CreateWindow("BUTTON", "HDD", BS_PUSHBUTTON | WS_VISIBLE | WS_CHILD | WS_TABSTOP, 10, 145, 200, 30, hWnd, (HMENU)ID_BUTTON_4, hInstance, NULL);
|
|
|
hBtn5 = CreateWindow("BUTTON", "Клавиатура", BS_PUSHBUTTON | WS_VISIBLE | WS_CHILD | WS_TABSTOP, 10, 185, 200, 30, hWnd, (HMENU)ID_BUTTON_5, hInstance, NULL);
hBtn6 = CreateWindow("BUTTON", "Системная плата", BS_PUSHBUTTON | WS_VISIBLE | WS_CHILD | WS_TABSTOP, 10, 225, 200, 30, hWnd, (HMENU)ID_BUTTON_6, hInstance, NULL);
hBtn7 = CreateWindow("BUTTON", "Мышь", BS_PUSHBUTTON | WS_VISIBLE | WS_CHILD | WS_TABSTOP, 10, 265, 200, 30, hWnd, (HMENU)ID_BUTTON_7, hInstance, NULL);
hBtn8 = CreateWindow("BUTTON", "Видеокарта", BS_PUSHBUTTON | WS_VISIBLE | WS_CHILD | WS_TABSTOP, 10, 305, 200, 30, hWnd, (HMENU)ID_BUTTON_8, hInstance, NULL);
hBtn9 = CreateWindow("BUTTON", "Монитор", BS_PUSHBUTTON | WS_VISIBLE | WS_CHILD | WS_TABSTOP, 10, 345, 200, 30, hWnd, (HMENU)ID_BUTTON_9, hInstance, NULL);
hBtn10 = CreateWindow("BUTTON", "Сетевые адаптеры", BS_PUSHBUTTON | WS_VISIBLE | WS_CHILD | WS_TABSTOP, 10, 385, 200, 30, hWnd, (HMENU)ID_BUTTON_10, hInstance, NULL);
hBtn11 = CreateWindow("BUTTON", "Приложения", BS_PUSHBUTTON | WS_VISIBLE | WS_CHILD | WS_TABSTOP, 10, 425, 200, 30, hWnd, (HMENU)ID_BUTTON_11, hInstance, NULL);
hBtn12 = CreateWindow("BUTTON", "Сбор данных в файл", BS_PUSHBUTTON | WS_VISIBLE | WS_CHILD | WS_TABSTOP, 10, 465, 200, 30, hWnd, (HMENU)ID_BUTTON_12, hInstance, NULL);
hBtn13 = CreateWindow("BUTTON", "Время работы Windows", BS_PUSHBUTTON | WS_VISIBLE | WS_CHILD | WS_TABSTOP, 10, 505, 200, 30, hWnd, (HMENU)ID_BUTTON_13, hInstance, NULL);
hBtn14 = CreateWindow("BUTTON", "Пользователь", BS_PUSHBUTTON | WS_VISIBLE | WS_CHILD | WS_TABSTOP, 10, 545, 200, 30, hWnd, (HMENU)ID_BUTTON_14, hInstance, NULL);
// Сюда будем помещать информацию о конфигурации
hwndEdit = CreateWindow("EDIT","",WS_BORDER | WS_VISIBLE | WS_CHILD| ES_MULTILINE | ES_AUTOVSCROLL | WS_VSCROLL | ES_READONLY,250,25,550,550,hWnd,(HMENU)ID_EDIT,hInstance, NULL);
|
|
|
ShowWindow(hWnd, nCmdShow);
UpdateWindow(hWnd);
return TRUE;
}
// Функция определения конфигурации процессора
char *GetProc(char *cStr)
{
HKEY hKey;
char cType[255],cProc[255];
DWORD cLen=255;
DWORD ProcessorFrequency;
DWORD cData=sizeof(ProcessorFrequency);
char cTmp[200];
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT("HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0"), 0, KEY_QUERY_VALUE, &hKey)==ERROR_SUCCESS)
{
RegQueryValueEx(hKey,"ProcessorNameString",NULL,NULL,(LPBYTE)cProc,&cLen);
RegQueryValueEx(hKey,"Identifier",NULL,NULL,(LPBYTE)cType,&cLen);
RegQueryValueEx(hKey,"~MHz",NULL,NULL,(LPBYTE)&ProcessorFrequency,&cData);
}
RegCloseKey(hKey);
// Формируем строку
cStr[0]='\0';
sprintf(cStr,"Название процессора: %s\r\nТип процессора: %s\r\nЧастота процессора: %ld МГц\r\n",cProc,cType,ProcessorFrequency);
if (IsProcessorFeaturePresent(PF_MMX_INSTRUCTIONS_AVAILABLE))
strcpy(cTmp,"Инструкции MMX поддерживаются\r\n");
else
strcpy(cTmp,"Инструкции MMX НЕ поддерживаются\r\n");
if (IsProcessorFeaturePresent(PF_XMMI_INSTRUCTIONS_AVAILABLE))
strcat(cTmp,"Инструкции SSE поддерживаются\r\n");
else
strcat(cTmp,"Инструкции SSE НЕ поддерживаются\r\n");
strcat(cStr,cTmp);
return(cStr);
}
// Функция определения конфигурации BIOS
char *GetBios(char *cStr)
{
HKEY hKey;
char cType[255],cBios[255];
DWORD cLen=255;
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT("HARDWARE\\DESCRIPTION\\System"), 0, KEY_QUERY_VALUE, &hKey)==ERROR_SUCCESS)
{
RegQueryValueEx(hKey,"SystemBiosVersion",NULL,NULL,(LPBYTE)cBios,&cLen);
RegQueryValueEx(hKey,"SystemBiosDate",NULL,NULL,(LPBYTE)cType,&cLen);
}
RegCloseKey(hKey);
// Формируем строку
cStr[0]='\0';
sprintf(cStr,"Название BIOS: %s\r\nДата изготовления: %s\r\n",cBios,cType);
return(cStr);
}
// Функция определения конфигурации BIOS
char *GetMB(char *cStr)
{
HKEY hKey;
char cType[255],cMan[255];
DWORD cLen=255;
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT("HARDWARE\\DESCRIPTION\\System\\BIOS"), 0, KEY_QUERY_VALUE, &hKey)==ERROR_SUCCESS)
{
RegQueryValueEx(hKey,"BaseBoardManufacturer",NULL,NULL,(LPBYTE)cMan,&cLen);
RegQueryValueEx(hKey,"BaseBoardProduct",NULL,NULL,(LPBYTE)cType,&cLen);
// Формируем строку
cStr[0]='\0';
sprintf(cStr,"Марка системной платы: %s\r\nПроизводитель: %s\r\n",cType,cMan);
}
else
sprintf(cStr,"Название Материнской платы: %s\r\nПроизводитель: %s\r\n","Не определено","Не определен");
RegCloseKey(hKey);
return(cStr);
}
// Функция определения конфигурации видеокарты
char* GetVideo(char *cStr)
{
HMODULE hUser32;
DISPLAY_DEVICE DispDev;
PFUNC EnumDisplayDevices;
char cTmp[200];
DEVMODE DevMode;
cStr[0]='\0';
hUser32 = LoadLibrary("user32.dll");
if (hUser32 == NULL)
return(cStr);
EnumDisplayDevices = (PFUNC)GetProcAddress(hUser32, "EnumDisplayDevicesA");
// Получаем указатель на EnumDisplayDevices
if (EnumDisplayDevices == NULL)
return(cStr);
// Теперь можно использовать EnumDisplayDevices с помощью указателя func
DispDev.cb = sizeof(DISPLAY_DEVICE);
if (EnumDisplayDevices(NULL, 0, &DispDev, 0))
{
sprintf(cTmp,"Видеоадаптер:\r\nНазвание адаптера:%s\r\n",(char *)DispDev.DeviceString);
strcat(cStr,cTmp);
if (EnumDisplaySettings((char *)DispDev.DeviceName,ENUM_CURRENT_SETTINGS,&DevMode))
{
sprintf(cTmp,"Драйвер: %s\r\nРазрешение экрана:%d x %d\r\nБит на пиксель:%d\r\nЧастота обновления:%d Гц\r\n",DevMode.dmDeviceName,DevMode.dmPelsWidth,DevMode.dmPelsHeight,DevMode.dmBitsPerPel,DevMode.dmDisplayFrequency);
strcat(cStr,cTmp);
}
}
return(cStr);
}
// Функция определения конфигурации видеокарты
char* GetMonitor(char *cStr)
{
HMODULE hUser32;
DISPLAY_DEVICE DispDev;
PFUNC EnumDisplayDevices;
char cTmp[200];
DEVMODE DevMode;
cStr[0]='\0';
hUser32 = LoadLibrary("user32.dll");
if (hUser32 == NULL)
return(cStr);
EnumDisplayDevices = (PFUNC)GetProcAddress(hUser32, "EnumDisplayDevicesA");
// Получаем указатель на EnumDisplayDevices
if (EnumDisplayDevices == NULL)
return(cStr);
// Теперь можно использовать EnumDisplayDevices с помощью указателя func
DispDev.cb = sizeof(DISPLAY_DEVICE);
if (EnumDisplayDevices(NULL, 0, &DispDev, 0))
{
sprintf(cTmp,"Монитор:\r\n");
strcat(cStr,cTmp);
if (EnumDisplaySettings((char *)DispDev.DeviceName,ENUM_CURRENT_SETTINGS,&DevMode))
{
sprintf(cTmp,"Разрешение экрана:%d x %d\r\nБит на пиксель:%d\r\nЧастота обновления:%d Гц\r\n",DevMode.dmPelsWidth,DevMode.dmPelsHeight,DevMode.dmBitsPerPel,DevMode.dmDisplayFrequency);
strcat(cStr,cTmp);
}
strcpy(cTmp, (char *)DispDev.DeviceName);
EnumDisplayDevices(cTmp, 0, &DispDev, 0);
sprintf(cTmp,"Название монитора:%s\r\n",(char *)DispDev.DeviceString);
strcat(cStr,cTmp);
}
return(cStr);
}
// Функция определения конфигурации дисковой подсистемы
char *GetDisk(char *cStr)
{
DWORD Drive;
char cTmp[200];
int i;
char cDisk[10],cVolume[50],cFileSysName[50];
DWORD SerNum,VolSize,FileSys;
ULARGE_INTEGER free,total,tot2;
Drive=GetLogicalDrives();
cStr[0]='\0';
for(i=1;i<32;i++)
{
if (Drive&(1<<i))
{
sprintf(cTmp,"Диск:%c\r\nТип диска:",'A'+i);
strcat(cStr,cTmp);
cDisk[0]=(char)'A'+i;
cDisk[1]=':';cDisk[2]='\\';
cDisk[3]='\0';
switch (GetDriveType(cDisk))
{
case DRIVE_UNKNOWN:strcpy(cTmp,"Неизвестный тип\r\n");break;
case DRIVE_NO_ROOT_DIR:strcpy(cTmp,"Неверный путь\r\n");break;
case DRIVE_REMOVABLE:strcpy(cTmp,"Съемный диск\r\n");break;
case DRIVE_FIXED:strcpy(cTmp,"Жесткий диск\r\n");break;
case DRIVE_REMOTE:strcpy(cTmp,"Сетевой диск\r\n");break;
case DRIVE_CDROM:strcpy(cTmp,"CD-ROM\r\n");break;
case DRIVE_RAMDISK:strcpy(cTmp,"Виртуальный диск\r\n");break;
}
strcat(cStr,cTmp);
cVolume[0]='\0';
cFileSysName[0]='\0';
SerNum=0;VolSize=0;FileSys=0;
GetVolumeInformation(cDisk,cVolume,sizeof(cVolume),&SerNum,&VolSize,&FileSys,cFileSysName,sizeof(cFileSysName));
sprintf(cTmp,"Имя тома:%s\r\nФайловая система:%s\r\n",cVolume,cFileSysName);
strcat(cStr,cTmp);
free.QuadPart=0;total.QuadPart=0;tot2.QuadPart=0;
GetDiskFreeSpaceEx(cDisk,&free,&total,&tot2);
sprintf(cTmp,"Общий объем:%lu Мб\r\nСвободно:%lu Мб\r\nЗанято:%ld Мб\r\n\r\n",(long)(total.QuadPart/(1024*1024)),(long)(free.QuadPart/(1024*1024)),(long)(total.QuadPart/(1024*1024))-(free.QuadPart/(1024*1024)));
strcat(cStr,cTmp);
}
}
return(cStr);
}
BOOL GetDriveGeometry(DISK_GEOMETRY *pdg, const char* driveName)
{
HANDLE hDevice;
BOOL bResult;
DWORD junk;
// формируем строку для получения хэндла диска. Необходимый формат "\\.\C:"
char str[7];
str[0] = str[1] = str[3] = '\\';
str[2] = '.';
str[4] = driveName[0];
str[5] = driveName[1];
str[6] = '\0';
// получаем хэндл диска
hDevice = CreateFileA(str, 0, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
OPEN_EXISTING, 0, NULL);
if (hDevice == INVALID_HANDLE_VALUE)
return FALSE;
// Получаем данные о диске
bResult = DeviceIoControl(hDevice, IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0,
pdg, sizeof(*pdg), &junk, (LPOVERLAPPED) NULL);
CloseHandle(hDevice);
return bResult;
}
// Функция определения конфигурации дисковой подсистемы
char *GetFizDisk(char *cStr)
{
DWORD Drive;
char cTmp[200];
int i,j;
char cDisk[10],cVolume[50],cFileSysName[50];
DWORD SerNum,VolSize,FileSys;
int n=0,f;
DISK_GEOMETRY SN[10];
DISK_GEOMETRY pdg;
BOOL bResult;
Drive=GetLogicalDrives();
cStr[0]='\0';
for(i=1;i<32;i++)
{
if (Drive&(1<<i))
{
cDisk[0]=(char)'A'+i;
cDisk[1]=':';cDisk[2]='\\';
cDisk[3]='\0';
switch (GetDriveType(cDisk))
{
case DRIVE_UNKNOWN:break;
case DRIVE_NO_ROOT_DIR:break;
case DRIVE_REMOVABLE:break;
case DRIVE_REMOTE:break;
case DRIVE_CDROM:break;
case DRIVE_RAMDISK:break;
case DRIVE_FIXED:cVolume[0]='\0';cFileSysName[0]='\0';SerNum=0;VolSize=0;FileSys=0;
GetVolumeInformation(cDisk,cVolume,sizeof(cVolume),&SerNum,&VolSize,&FileSys,cFileSysName,sizeof(cFileSysName));
// Проверяем, есть ли в списке этот диск
bResult = GetDriveGeometry (&pdg, cDisk);
f=0;
for(j=0;j<n;j++)
if (SN[j].BytesPerSector==pdg.BytesPerSector&&SN[j].Cylinders.QuadPart==pdg.Cylinders.QuadPart&&SN[j].MediaType==pdg.MediaType&&SN[j].SectorsPerTrack==pdg.SectorsPerTrack&&SN[j].TracksPerCylinder==pdg.TracksPerCylinder)
f=1;
if (f==0) // Если не было еще диска
{
SN[n]=pdg;
n++;
sprintf(cTmp,"Жесткий диск №%1d.\r\n Цилиндров = %I64d Дорожек на цилиндр:%ld\r\nСекторов на дорожку: %ld Байт на сектор:%ld\r\n Общий размер: %I64d Байт \r\n",n-1,pdg.Cylinders,pdg.TracksPerCylinder,pdg.SectorsPerTrack,pdg.BytesPerSector,pdg.Cylinders.QuadPart*((ULONG)pdg.TracksPerCylinder)*((ULONG)pdg.SectorsPerTrack)*((ULONG)pdg.BytesPerSector));
strcat(cStr,cTmp);
}
break;
}
}
}
return(cStr);
}
// Функция запрашиваем информацию об клавиатуре
char *GetInpKl(char *cStr)
{
char cTmp[200];
cStr[0]='\0';
strcpy(cStr,"Тип клавиатуры:\r\n");
switch(GetKeyboardType(0))
{
case 1:strcpy(cTmp,"IBM PC/XT или совместимая (83 клавиши) клавиатура\r\n");break;
case 2:strcpy(cTmp,"Olivetti \"ICO\" (102 клавиши) клавиатура\r\n");break;
case 3:strcpy(cTmp,"IBM PC/AT (84 клавиши) или сходная с ней клавиатура\r\n");break;
case 4:strcpy(cTmp,"IBM enhanced (101 или 102 клавиши) клавиатура\r\n");break;
case 5:strcpy(cTmp,"Nokia 1050 и сходная с ней клавиатура\r\n");break;
case 6:strcpy(cTmp,"Nokia 9140 и сходная с ней клавиатура\r\n");break;
case 7:strcpy(cTmp,"Японская клавиатура\r\n");break;
default:strcpy(cTmp,"Не удалось определить\r\n");break;
}
strcat(cStr,cTmp);
return(cStr);
}
// Функция запрашиваем информацию об мыши
char *GetInpMouse(char *cStr)
{
char cTmp[200];
cStr[0]='\0';
switch (GetSystemMetrics(SM_CMOUSEBUTTONS))
{
case 0: strcpy(cTmp,"Нет мыши в системе\r\n");break;
default:sprintf(cTmp,"Мышь с %d кнопками",GetSystemMetrics(SM_CMOUSEBUTTONS));break;
}
strcat(cStr,cTmp);
return(cStr);
}
// Функция получает сетевую информацию
char *GetNetAdapter(char *cStr)
{
PIP_ADAPTER_INFO pAdapterInfo = NULL;
PIP_ADAPTER_INFO pAdapter = NULL;
DWORD dwRetVal = 0;
ULONG ulOutBufLen;
char cTmp[200];
cStr[0]='\0';
ulOutBufLen = sizeof (IP_ADAPTER_INFO);
pAdapterInfo = (IP_ADAPTER_INFO *) MALLOC(sizeof (IP_ADAPTER_INFO));
if (pAdapterInfo == NULL)
return(cStr);
if( (dwRetVal = GetAdaptersInfo(pAdapterInfo, &ulOutBufLen)) == NO_ERROR )
{
pAdapter = pAdapterInfo;
while( pAdapter )
{
sprintf(cTmp,"Системное имя: %s\r\n", pAdapter->AdapterName);
strcat(cStr,cTmp);
sprintf(cTmp,"Сетевой адаптер: %s\r\n", pAdapter->Description);
strcat(cStr,cTmp);
switch (pAdapter->Type) {
case MIB_IF_TYPE_OTHER:
sprintf(cTmp,"Тип адаптера:Other\r\n");
break;
case MIB_IF_TYPE_ETHERNET:
sprintf(cTmp,"Тип адаптера:Ethernet\r\n");
break;
case MIB_IF_TYPE_TOKENRING:
sprintf(cTmp,"Тип адаптера:Token Ring\r\n");
break;
case MIB_IF_TYPE_FDDI:
sprintf(cTmp,"Тип адаптера:FDDI\r\n");
break;
case MIB_IF_TYPE_PPP:
sprintf(cTmp,"Тип адаптера:PPP\r\n");
break;
case MIB_IF_TYPE_LOOPBACK:
sprintf(cTmp,"Тип адаптера:Lookback\r\n");
break;
case MIB_IF_TYPE_SLIP:
sprintf(cTmp,"Тип адаптера:Slip\r\n");
break;
default:
sprintf(cTmp,"Тип адаптера: Unknown type %ld\r\n", pAdapter->Type);
break;
}
strcat(cStr,cTmp);
sprintf(cTmp,"IP адрес: %s\r\n",pAdapter->IpAddressList.IpAddress.String);
strcat(cStr,cTmp);
sprintf(cTmp,"IP маска: %s\r\n", pAdapter->IpAddressList.IpMask.String);
strcat(cStr,cTmp);
sprintf(cTmp,"Шлюз: %s\r\n", pAdapter->GatewayList.IpAddress.String);
strcat(cStr,cTmp);
pAdapter = pAdapter->Next;
}
}
FREE(pAdapterInfo);
return(cStr);
}
// Функция получает информацию о запущенных приложениях
char *GetApplication(char *cStr)
{
PROCESSENTRY32 PE32;
char cTmp[200];
cStr[0]='\0';
sprintf(cStr,"Запущенные процессы:\r\n");
HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if(hSnapshot == INVALID_HANDLE_VALUE)
{
sprintf(cStr,"CreateToolhelp32Snapshot() не удалось выполнить.");
return(cStr);
}
if(!Process32First(hSnapshot, &PE32))
{
CloseHandle(hSnapshot);
sprintf(cStr,"Process32First() не удалось выполнить.");
return(cStr);
}
do
{
sprintf(cTmp,"%s\r\n", PE32.szExeFile);
strcat(cStr,cTmp);
}
while(Process32Next(hSnapshot, &PE32));
CloseHandle(hSnapshot);
return(cStr);
}
// Формируем строку с временем, когда было создано сообщение
void GetTimestamp(const DWORD Time, char *DisplayString)
{
ULONGLONG ullTimeStamp = 0;
ULONGLONG SecsTo1970 = 116444736000000000;
SYSTEMTIME st;
FILETIME ft, ftLocal;
ullTimeStamp = Int32x32To64(Time, 10000000) + SecsTo1970;
ft.dwHighDateTime = (DWORD)((ullTimeStamp >> 32) & 0xFFFFFFFF);
ft.dwLowDateTime = (DWORD)(ullTimeStamp & 0xFFFFFFFF);
FileTimeToLocalFileTime(&ft, &ftLocal);
FileTimeToSystemTime(&ftLocal, &st);
sprintf(DisplayString,"\t %d/%d/%d %.2d:%.2d:%.2d\t", st.wDay, st.wMonth, st.wYear, st.wHour, st.wMinute, st.wSecond);
}
// Функция определяем тип операционной системы
char *WorkTime(char *cStr)
{
OSVERSIONINFO osvi;
char cTmp[200];
HANDLE hEventSource;
DWORD dwBytesToRead = 0;
DWORD dwBytesRead = 0;
DWORD dwMinimumBytesToRead = 0;
char TimeStamp[MAX_TIMESTAMP_LEN];
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
GetVersionEx(&osvi);
sprintf(cStr,"Версия операционной системы:%ld.%ld \r\nНомер сборки:%ld \r\n%s\r\n",osvi.dwMajorVersion,osvi.dwMinorVersion,osvi.dwBuildNumber,osvi.szCSDVersion);
// Открываем журнал System
hEventSource = RegisterEventSource(NULL,"System");
if(hEventSource!=NULL)
{
// Считыавем сообщения
dwBytesToRead = MAX_RECORD_BUFFER_SIZE;
while (ReadEventLog(hEventSource,EVENTLOG_SEQUENTIAL_READ | EVENTLOG_BACKWARDS_READ,0,cBuffer,dwBytesToRead,&dwBytesRead,&dwMinimumBytesToRead))
{
PBYTE pRecord = (PBYTE)cBuffer;
PBYTE pEndOfRecords = (PBYTE)cBuffer + dwBytesRead;
// Пока не закончились записи в буфере
while (pRecord < pEndOfRecords)
{
if ((((PEVENTLOGRECORD)pRecord)->EventID & 0xFFFF)==6005) // Запуск Windows
{
// Выделяем из записи время
GetTimestamp(((PEVENTLOGRECORD)pRecord)->TimeGenerated, TimeStamp);
sprintf(cTmp,"Запуск windows: %s\r\n",TimeStamp);
strcat(cStr,cTmp);
}
if ((((PEVENTLOGRECORD)pRecord)->EventID & 0xFFFF)==6006) // Завершение Windows
{
// Выделяем из записи время
GetTimestamp(((PEVENTLOGRECORD)pRecord)->TimeGenerated, TimeStamp);
sprintf(cTmp,"Завершение windows: %s\r\n",TimeStamp);
strcat(cStr,cTmp);
}
// Переходим на следующую запись
pRecord += ((PEVENTLOGRECORD)pRecord)->Length;
}
}
DeregisterEventSource(hEventSource);
}
return(cStr);
}
// Функция определяет системную информацию
char *GetUser(char *cStr)
{
DWORD size;
char cComp[50],cUser[50];
size=sizeof(cComp);
GetComputerName(cComp,&size);
size=sizeof(cUser);
GetUserName(cUser,&size);
sprintf(cStr,"Имя компьютера:%s\r\nИмя пользователя:%s\r\n",cComp,cUser);
return(cStr);
}
char *SaveToFile(char *cStr,HWND hWnd)
{
char szFileName[MAX_PATH] = "";
OPENFILENAME ofn;
FILE *f;
cStr[0]='\0';
// В диалоге просим назначить имя файла
ZeroMemory(&ofn, sizeof(OPENFILENAME));
ofn.lStructSize = sizeof(OPENFILENAME);
ofn.hwndOwner = hWnd;
ofn.lpstrFilter =
"Text files (*.txt)\0*.txt\0"
"All files (*.*)\0*.*\0";
ofn.lpstrFile = szFileName;
ofn.nMaxFile = MAX_PATH;
ofn.lpstrTitle = "Имя файла для сохранения конфигурации";
ofn.Flags = OFN_CREATEPROMPT|OFN_PATHMUSTEXIST|OFN_HIDEREADONLY;
ofn.lpstrDefExt = "txt";
if(GetOpenFileName(&ofn))
{
// Открываем файл
if ((f=fopen(szFileName,"w"))==NULL)
{
return(cStr);
}
// Построчно сохраняем конфигурацию
fprintf(f,"%s",GetProc(cStr));
fprintf(f,"%s",GetBios(cStr));
fprintf(f,"%s",GetDisk(cStr));
fprintf(f,"%s",GetFizDisk(cStr));
fprintf(f,"%s",GetInpKl(cStr));
fprintf(f,"%s",GetMB(cStr));
fprintf(f,"%s",GetInpMouse(cStr));
fprintf(f,"%s",GetVideo(cStr));
fprintf(f,"%s",GetMonitor(cStr));
fprintf(f,"%s",GetNetAdapter(cStr));
fprintf(f,"%s",GetApplication(cStr));
fprintf(f,"%s",WorkTime(cStr));
fprintf(f,"%s",GetUser(cStr));
// Закрываем файл
sprintf(cStr,"Данные в файл сохранены");
fclose(f);
}
return(cStr);
}
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
int wmId, wmEvent;
char cStr[10000];
switch (message)
{
case WM_COMMAND:
wmId = LOWORD(wParam);
wmEvent = HIWORD(wParam);
// Parse the menu selections:
switch (wmId)
{
// Определение конфигурации процессора
case ID_BUTTON_1:SendMessage(hwndEdit,WM_SETTEXT,NULL,(LPARAM) GetProc(cStr));
break;
// Определение конфигурации BIOS
case ID_BUTTON_2:SendMessage(hwndEdit,WM_SETTEXT,NULL,(LPARAM) GetBios(cStr));
break;
// Определение конфигурации разделов hdd
case ID_BUTTON_3:SendMessage(hwndEdit,WM_SETTEXT,NULL,(LPARAM) GetDisk(cStr));
break;
// Определение конфигурации дисковой подсистемы
case ID_BUTTON_4:SendMessage(hwndEdit,WM_SETTEXT,NULL,(LPARAM) GetFizDisk(cStr));
break;
// Запрашиваем информацию об клавиатуре
case ID_BUTTON_5:SendMessage(hwndEdit,WM_SETTEXT,NULL,(LPARAM) GetInpKl(cStr));
break;
// Получение информации о материнской плате
case ID_BUTTON_6:SendMessage(hwndEdit,WM_SETTEXT,NULL,(LPARAM) GetMB(cStr));
break;
// Определяем тип операционной системы
case ID_BUTTON_7:SendMessage(hwndEdit,WM_SETTEXT,NULL,(LPARAM) GetInpMouse(cStr));
break;
// Системная информация
case ID_BUTTON_8:SendMessage(hwndEdit,WM_SETTEXT,NULL,(LPARAM) GetVideo(cStr));
break;
case ID_BUTTON_9:SendMessage(hwndEdit,WM_SETTEXT,NULL,(LPARAM) GetMonitor(cStr));
break;
case ID_BUTTON_10:SendMessage(hwndEdit,WM_SETTEXT,NULL,(LPARAM) GetNetAdapter(cStr));
break;
case ID_BUTTON_11:SendMessage(hwndEdit,WM_SETTEXT,NULL,(LPARAM) GetApplication(cStr));
break;
case ID_BUTTON_12:SendMessage(hwndEdit,WM_SETTEXT,NULL,(LPARAM) SaveToFile(cStr,hWnd));
break;
case ID_BUTTON_13:SendMessage(hwndEdit,WM_SETTEXT,NULL,(LPARAM) WorkTime(cStr));
break;
case ID_BUTTON_14:SendMessage(hwndEdit,WM_SETTEXT,NULL,(LPARAM) GetUser(cStr));
break;
case IDM_ABOUT:
DialogBox(hInst, (LPCTSTR)IDD_ABOUTBOX, hWnd, (DLGPROC)About);
break;
case IDM_EXIT:
DestroyWindow(hWnd);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return 0;
}
// Функция обработки сообщения диалогового окна о программе...
LRESULT CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)
{
case WM_INITDIALOG:
return TRUE;
case WM_COMMAND:
if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
{
EndDialog(hDlg, LOWORD(wParam));
return TRUE;
}
break;
}
return FALSE;
}
Дата добавления: 2019-01-14; просмотров: 203; Мы поможем в написании вашей работы! |
Мы поможем в написании ваших работ!