Информация о системе

#include <stdio.h>
#define  OS_TYPE  0xF0    //0xF0 - Windows, 0x0F - Linux
 
 
#if   OS_TYPE & 0xF0   // Windows
#include <Windows.h>
 
// MAX_COMPUTERNAME_LENGTH
int  get_computer_name(char*  name, unsigned long size) {
     return GetComputerName(name, &size);
}
 
#else if OS_TYPE & 0x0F   // Linux
#include <unistd.h>
#include <sys/param.h>
 
// MAXHOSTNAMELEN
int  get_computer_name(char*  name, unsigned long size) {
     return gethostname(name, size);
}
 
#endif
 
 
 
 
int main(int argc, char* argv[])
{
   char name[255] = { '\0' };
   get_computer_name(name, 255);
   printf("computer name: %s\n", name);
 
   getchar();
   return 0;
}

#include <stdio.h>
#include <pdh.h>
#include <conio.h>
 
#pragma comment(lib,"pdh.lib")
 
/*****************************************************************************/
/**********                                                         **********/
/**********            PDH - performance data helper                **********/
/**********                                                         **********/
/*****************************************************************************/
 
/************************** Описание наших функций ***************************/
 
#define PDH_ERROR -1
// Функция инициализирует PDH (performance data helper)
PDH_STATUS pdh_Init (HQUERY &hQuery, HCOUNTER &hCounter);
// Функция возвращает в случае удачи загруженность проца, в противном случае PHG_ERROR (-1)
int GetCPUUsage (HQUERY hQuery, HCOUNTER hCounter, PDH_STATUS &pdhStatus);
// Функция анинициализирует PDH
void pdh_Uninit (HQUERY hQuery, HCOUNTER hCounter);
// Функция показывает сообщение об ошибке
void ShowErrorMessage(PDH_STATUS pdhStatus);
// хмм... в названии функции все сказано!
void begin();
 
/****************************************************************************/
 
 
void main(void)
{
    Sleep(1000);
    begin();
    printf(TEXT("Press any key to continue")); // нажмите "any key" на клавиатуре 
    while (!_getch()); // ждем, пока юзверь не "клацнет" "any key"
}
 
void begin()
// хмм... в названии функции все сказано!
{
    PDH_STATUS  pdhStatus      = 0;
 
    HQUERY hQuery;
    HQUERY hCounter;
    int iUsage = 0;
    pdhStatus = pdh_Init(hQuery, hCounter); // инициализируем PDH
 
 // если не произошел облом с иницализации PDH, то
    if ( pdhStatus == ERROR_SUCCESS )
    {
 // пока юзверь не зажмет клавишу Esc, то
       while (GetKeyState(VK_ESCAPE) >= 0)
        {
 // получаем загруженность проца
            iUsage = GetCPUUsage(hQuery, hCounter, pdhStatus);
 
 // если не произошла ошибка (т.е. не вернулось значение PHG_ERROR)
            if (iUsage != PDH_ERROR)
                printf("%3i%%\r\n", iUsage); // выводим значение
            else // а если произошла ошибка, то
// показываем сообщение, что произошла ошибка такая-то
            ShowErrorMessage(pdhStatus);
 //         Sleep(500); // ждем 0.5 секунд(ы)
        }
// если юзверь все-таки клацнул Esc, то флаг ему в руки :)
        pdh_Uninit(hQuery, hCounter); // заканчиваем работу с PDH
    }
    else // если произошла ошибка при инициализации PDH
        ShowErrorMessage(pdhStatus); // показываем Еррорное сообщение
}
 
void ShowErrorMessage(PDH_STATUS pdhStatus)
// Сама функция показа сообщения об ошибке
{
    LPSTR szMessage = NULL;
// грузим строку с ошибкой в szMessage. Память выделит функция
    FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
                    FORMAT_MESSAGE_FROM_HMODULE,
                    GetModuleHandle("PDH.DLL"), pdhStatus,
                    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                    szMessage, 0, NULL);
    printf("Error №%i:  %s\r\n", pdhStatus, szMessage); // показываем ошибку
    LocalFree(szMessage); // очищаем буфер
}
 
PDH_STATUS pdh_Init(HQUERY &hQuery, HCOUNTER &hCounter)
// инициализируем PDH
{
    PDH_STATUS  pdhResult   = 0;
    TCHAR       szCounterPath[1024];
    DWORD       dwPathSize  = 1024;
    PDH_COUNTER_PATH_ELEMENTS pe;
    DWORD       dwType      = 0;
    
    pdhResult = PdhOpenQuery( NULL, 0, &hQuery ); // запрос на открытие PDH 
    if ( pdhResult != ERROR_SUCCESS ) // если была ошибка, то
        return pdhResult; // выходим, возвращая номер ошибки
 
    pe.szMachineName     = 0l;
    pe.szObjectName      = "Processor";
    pe.szInstanceName    = "_Total";
    pe.szParentInstance  = NULL;
    pe.dwInstanceIndex   = 0;
    pe.szCounterName     = "% Processor Time";
 
// создаем путь к счетчику PDH
    pdhResult = PdhMakeCounterPath(&pe, szCounterPath, &dwPathSize, 0);
    if (pdhResult != ERROR_SUCCESS) // если была ошибка, то
        return pdhResult; // выходим, возвращая номер ошибки
// открываем счетчик PDH
    pdhResult = PdhAddCounter(hQuery, szCounterPath, 0, &hCounter);
    if (pdhResult != ERROR_SUCCESS) // если была ошибка, то
        return pdhResult; // выходим, возвращая номер ошибки
 // если дошли до этого места, то ошибки на 100% не было!
    return pdhResult;
}
 
int GetCPUUsage(HQUERY hQuery, HCOUNTER hCounter, PDH_STATUS &pdhStatus)
// получаем загруженность проца
{
    DWORD       dwType      = 0;
// даем запрос на сборы инфы
    pdhStatus = PdhCollectQueryData(hQuery);
    if (pdhStatus != ERROR_SUCCESS) // если была ошибка, то
        return PDH_ERROR; // выходим, возвращая ошибку
    _PDH_FMT_COUNTERVALUE pfci;
    ZeroMemory(&pfci, sizeof(pfci)); // очищаем структуру pfci
// Получаем инфу о загруженности проца!
    pdhStatus = PdhGetFormattedCounterValue( hCounter, PDH_FMT_DOUBLE, &dwType, &pfci); 
    if (pdhStatus != ERROR_SUCCESS) // если была ошибка, то
        return PDH_ERROR; // выходим, возвращая ошибку
    return (int)pfci.doubleValue; // возвращаем загруженность проца!
} 
 
void pdh_Uninit(HQUERY hQuery, HCOUNTER hCounter)
// анинициализация 
{
    PdhRemoveCounter(hCounter); // удаляем счетчик
    PdhCloseQuery(hQuery); // закрываем запрос
}

// SysInfo.cpp : Defines the entry point for the console application.
//
 
#include <windows.h>
#include <stdio.h>
//#include <winsock2.h>
#include <iostream.h>
#include <conio.h>
#include <tchar.h> 
#include <tlhelp32.h>
 
#pragma comment(lib,"wsock32.lib")
 
#define BUFSIZE 1024
 
void HardWareInfo()
{
    SYSTEM_INFO siSysInfo;
 
   // Копируем информацию о железе в структуру SYSTEM_INFO.
 
   GetSystemInfo(&siSysInfo);
 
   // Отображаем содержимое структуры SYSTEM_INFO.
 
   printf("Hardware information: \n");
   printf("  OEM ID: %u\n", siSysInfo.dwOemId);
   printf("  Number of processors: %u\n",
      siSysInfo.dwNumberOfProcessors);
   printf("  Page size: %u\n", siSysInfo.dwPageSize);
   printf("  Processor type: %u\n", siSysInfo.dwProcessorType);
   printf("  Minimum application address: %lx\n",
      siSysInfo.lpMinimumApplicationAddress);
   printf("  Maximum application address: %lx\n",
      siSysInfo.lpMaximumApplicationAddress);
   printf("  Active processor mask: %u\n",
      siSysInfo.dwActiveProcessorMask);
}
 
void MyErrorExit(LPCTSTR ErrMsg)
{
    printf("Error :");
    printf(ErrMsg);
    printf("Error :\r\n");
}
 
void GetSampleServiceConfig()
{
    LPQUERY_SERVICE_CONFIG lpqscBuf;
    LPSERVICE_DESCRIPTION lpqscBuf2;
    DWORD dwBytesNeeded;
 
    // Открываем дескриптор сервиса.
    SC_HANDLE schSCManager;
 
    SC_HANDLE schService = OpenService(
        schSCManager,           // база данных SCManager
        "Sample_Srv",           // имя сервиса
        SERVICE_QUERY_CONFIG);  // нужно только получить
    if (schService == NULL)
        MyErrorExit("OpenService");
 
    // Выделяем буфер для информации о настройках сервиса.
 
    lpqscBuf = (LPQUERY_SERVICE_CONFIG) LocalAlloc(
        LPTR, 4096);
    if (lpqscBuf == NULL)
        MyErrorExit("LocalAlloc");
 
    lpqscBuf2 = (LPSERVICE_DESCRIPTION) LocalAlloc(
        LPTR, 4096);
    if (lpqscBuf2 == NULL)
        MyErrorExit("LocalAlloc");
 
    // Получаем настройки сервиса.
 
    if (! QueryServiceConfig(
        schService,
        lpqscBuf,
        4096,
        &dwBytesNeeded) )
    {
        MyErrorExit("QueryServiceConfig");
    }
 
/*    if (! QueryServiceConfig2(
        schService,
        SERVICE_CONFIG_DESCRIPTION,
        lpqscBuf2,
        4096,
        &dwBytesNeeded) )
    {
        MyErrorExit("QueryServiceConfig2");
    }*/
 
    // Распечатываем настройки сервиса.
 
    printf("\nSample_Srv configuration: \n");
    printf(" Тип: 0x%x\n", lpqscBuf->dwServiceType);
    printf(" Тип запуска: 0x%x\n", lpqscBuf->dwStartType);
    printf(" Контроль ошибок: 0x%x\n", lpqscBuf->dwErrorControl);
    printf(" Путь сервиса: %s\n", lpqscBuf->lpBinaryPathName);
 
    if (lpqscBuf->lpLoadOrderGroup != NULL)
        printf(" Группа: %s\n", lpqscBuf->lpLoadOrderGroup);
    if (lpqscBuf->dwTagId != 0)
        printf(" Идентификатор в группе: %d\n", lpqscBuf->dwTagId);
    if (lpqscBuf->lpDependencies != NULL)
        printf(" Зависимости: %s\n", lpqscBuf->lpDependencies);
    if (lpqscBuf->lpServiceStartName != NULL)
        printf(" Имя: %s\n", lpqscBuf->lpServiceStartName);
    if (lpqscBuf2->lpDescription != NULL)
        printf(" Описание: %s\n", lpqscBuf2->lpDescription);
 
    LocalFree(lpqscBuf);
    LocalFree(lpqscBuf2);
}
 
void GetCompIP()
{
    WSADATA wsaData;
    if (!WSAStartup(!NULL, &wsaData)) 
    {
        char chInfo[64];
        if (!gethostname(chInfo,sizeof(chInfo)))
        {
            cout << chInfo << endl;
            hostent *sh;
            sh=gethostbyname((char*)&chInfo);
            if (sh!=NULL)
            {
            cout << sh->h_name << endl;
            int nAdapter = 0;
            while ( sh->h_addr_list[nAdapter] )
            {
            struct sockaddr_in adr;
            memcpy(&adr.sin_addr,sh->h_addr_list[nAdapter],sh->h_length); 
            cout << inet_ntoa(adr.sin_addr) << endl;
            nAdapter++;
            }
            }
        }
        else
            cout << "Error local host " << endl;
    }
    else
        cout << "Winsock initial Bad !!!!" << endl;
    WSACleanup();
}
 
void EnumerateSerialPorts()
{
    // В какой системе работаем?
    OSVERSIONINFO osvi;
    osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
    BOOL bGetVer = GetVersionEx(&osvi);
 
    // В NT используем API QueryDosDevice
    if(bGetVer && (osvi.dwPlatformId == VER_PLATFORM_WIN32_NT))
    {
 
        // Используем QueryDosDevice для просмотра всех устройств похожих на COMx.
        // Это наилучшее решение, так как порты не требуется открывать
 
        TCHAR szDevices[65535];
        DWORD dwChars = QueryDosDevice(NULL, szDevices, 65535);
        if(dwChars)
        {
            int i=0;
            for (;;)
            {
                // Получаем текущее имя устройства
                TCHAR* pszCurrentDevice = &szDevices[i];
                // Если похоже на "COMX" выводим на экран
                int nLen = _tcslen(pszCurrentDevice);
                if(nLen > 3 && _tcsnicmp(pszCurrentDevice, _T("COM"), 3) == 0)
                {
                    printf(pszCurrentDevice);
                    printf("\n");
                }
                // Переходим к следующему символу терминатору
                while(szDevices[i] != _T('\0'))
                    i++;
                // Перескакиваем на следующую строку
                i++;
                // Список завершается двойным симмволом терминатором, так что если символ
                // NULL, мы дошли до конца
                if(szDevices[i] == _T('\0'))
                    break;
            } // for (;;)
        } // if(dwChars)
    } // if(bGetVer && (osvi.dwPlatformId == VER_PLATFORM_WIN32_NT))
    else
    {
        // В 95/98 открываем каждый порт для определения его существования
        // Поддерживается до 255 COM портов, так что мы проходим пл всему списку
        // Если мы не можем открыть порт, или происходит ошибка при открытии,
        // получаем access denied или общую ошибку все эти случаи указывают на
        // то, что под таким номером есть порт.
        for (UINT i=1; i<256; i++)
        {
            // Формируем сырое имя устройства
            char sPort[10];
            sprintf(sPort,"\\\\.\\COM%d", i);
            // Пытаемся открыть каждый порт
            BOOL bSuccess = FALSE;
            HANDLE hPort = ::CreateFile(sPort, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0);
            if(hPort == INVALID_HANDLE_VALUE)
            {
                DWORD dwError = GetLastError();
                // Смотрим что получилось при открытии
                if(dwError == ERROR_ACCESS_DENIED || dwError == ERROR_GEN_FAILURE)
                    bSuccess = TRUE;
            }
            else
            {
                // Порт открыт успешно
                bSuccess = TRUE;
                // Не забываем закрывать каждый открытый порт,
                // так как мы не собираемся с ним работать...
                CloseHandle(hPort);
            } // if(hPort == INVALID_HANDLE_VALUE)
            // Выводим на экран название порта
            if(bSuccess)
            {
                printf(sPort);
                printf("\n");
            }
        } // for (UINT i=1; i<256; i++)
    } // if(bGetVer && (osvi.dwPlatformId == VER_PLATFORM_WIN32_NT))
}
 
 
 
void ScanProcess() 
{
    HANDLE hSnap;
    hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hSnap == NULL) 
    {
        MessageBox(NULL,"Error Load ToolHelp",NULL,MB_OK);
    }
    PROCESSENTRY32 proc;
    THREADENTRY32 te32;
    if (Process32First(hSnap, &proc))
    {
        printf(proc.szExeFile);
//      cout <<  te32.th32ThreadID << " " << te32.th32OwnerProcessID << endl;
        printf("\r\n");
        while (Process32Next(hSnap, &proc)) 
        {
            printf(proc.szExeFile);
//          Thread32Next(hSnap, &te32);
//          cout <<  te32.th32ThreadID << " " << te32.th32OwnerProcessID << endl; 
            printf("\r\n");
        }
    }
}
 
void main()
{
   LPTSTR lpszSystemInfo;      // указатель на строку, в которой
                               // будет информация о системе.
   DWORD cchBuff = 256;        // длина имени компьютера или
                               // пользователя.
   TCHAR tchBuffer[BUFSIZE];   // буфер для строки.
 
   DWORD dwResult;             // возвращаемое значение функции.
 
   lpszSystemInfo = tchBuffer;
 
   // Получаем и отображаем имя компьютера.
 
   if( GetComputerName(lpszSystemInfo, &cchBuff) )
      printf("Computer name:  %s\n", lpszSystemInfo);
 
   // Получаем и отображаем имя пользователя.
 
   if( GetUserName(lpszSystemInfo, &cchBuff) )
      printf("User name:  %s\n\n", lpszSystemInfo);
 
   // Получаем и отображаем системную директорию.
 
   if( GetSystemDirectory(lpszSystemInfo, MAX_PATH+1) )
      printf("System directory:  %s\n", lpszSystemInfo);
 
   // Получаем и отображаем директорию Windows.
 
   if( GetWindowsDirectory(lpszSystemInfo, MAX_PATH+1) )
      printf("Windows directory:  %s\n\n", lpszSystemInfo);
 
 
   printf("Переменные окружения (partial list): \n");
 
   // Получаем переменную окружения OS.
 
   dwResult = ExpandEnvironmentStrings(
                 "OS=%OS%",
                 lpszSystemInfo,
                 BUFSIZE);
   if( dwResult <= BUFSIZE )
      printf("  %s\n", lpszSystemInfo);
 
 
   // Получаем переменную окружения PATH.
 
   dwResult = ExpandEnvironmentStrings(
                 "PATH=%PATH%",
                 lpszSystemInfo,
                 BUFSIZE);
   if( dwResult <= BUFSIZE )
      printf("  %s\n", lpszSystemInfo);
 
   // Получаем переменную окружения TMP.
 
   dwResult = ExpandEnvironmentStrings(
               "TEMP=%TEMP%",
               lpszSystemInfo,
               BUFSIZE);
   if( dwResult <= BUFSIZE )
      printf("  %s\n", lpszSystemInfo);
 
   //addition 1
   GetSampleServiceConfig();
   //addition 2
   HardWareInfo();
   //addition 3
   GetCompIP();
   //addition 4
   EnumerateSerialPorts();
   //addition 5
   ScanProcess();
 
   getch();
}

// ListDrives.cpp : Defines the entry point for the console application.
//
#include "windows.h"
#include "winbase.h"
#include "tchar.h" //_tcslen()
#include "stdio.h" //printf
#include "conio.h"
 
 
#define DRIVE_UNKNOWN     0   // Неправильное имя
#define DRIVE_NO_ROOT_DIR 1   // Неправильное имя: отсутствует диск
#define DRIVE_REMOVABLE   2   // Съёмное устройство (магнито-оптика, zip)
#define DRIVE_FIXED       3   // жёсткий диск (обычный винчестер)
#define DRIVE_REMOTE      4   // сетевой диск
#define DRIVE_CDROM       5   // CD-ROM
#define DRIVE_RAMDISK     6   // RAM диск
 
void GetVolumeInfo (char* Volume);
void SetWndIco(int index);
 
//////////////////
// Простая таблица соответствия кодов из GetDriveType и читабельным
// названиям типов дисков
//
struct {
   UINT type;        // возвращаемый код из GetDriveType
   LPCSTR name;      // ascii имя
} DriveTypeFlags [] = {
   { DRIVE_UNKNOWN,     "Unknown" },
   { DRIVE_NO_ROOT_DIR, "Invalid path" },
   { DRIVE_REMOVABLE,   "Removable" },
   { DRIVE_FIXED,       "Fixed" },
   { DRIVE_REMOTE,      "Network drive" },
   { DRIVE_CDROM,       "CD-ROM" },
   { DRIVE_RAMDISK,     "RAM disk" },
   { 0, NULL},
};
 
void main(/*int argc, char* argv[]*/)
{
    SetWndIco(15);
    TCHAR buf[100];
    DWORD len = GetLogicalDriveStrings(sizeof(buf)/sizeof(TCHAR),buf);
 
    // Показываем информацию о каждом диске.
    //
    
    LPCTSTR msg  = "Logical Drives:\n";  // строка STL
    printf(msg);
    for (TCHAR* s=buf; *s; s+=_tcslen(s)+1) 
    {
        LPCTSTR sDrivePath = s;
        //msg += sDrivePath;
        //msg += " ";
        printf(sDrivePath);
        printf(" ");
        
        // GetDriveType получает одно из перечисленных значений
        // DRIVE_UNKNOWN, и т.д.
        //
        UINT uDriveType = GetDriveType(sDrivePath);
 
        // Находим тип диска в таблице.
        //
        for (int i=0; DriveTypeFlags[i].name; i++) 
        {
            if (uDriveType == DriveTypeFlags[i].type) 
            {
//              msg += DriveTypeFlags[i].name;
                printf(DriveTypeFlags[i].name);
                strcpy(buf,sDrivePath);
                GetVolumeInfo(buf);
                break;
             }
        }
//      msg += '\n';
        printf("\n");
    }
//  cout << msg.c_str()*/;
    printf("Press any key to exit\r\n");
    getch();
    //return 0;
}
 
void GetVolumeInfo (char* Volume)
{
    char Name [MAX_PATH];
    char FileSysName [256];
    DWORD SerialNumber;
    DWORD MaxLength;
    DWORD FileSysFlags;
    DWORD SectorsPerCluster;
    DWORD BytesPerSector;
    DWORD NumberOfFreeClusters;
    DWORD TotalNumberOfClusters;
 
    char str[MAX_PATH];
    if (GetVolumeInformation (
            Volume,
            Name,
            256,
            &SerialNumber,
            &MaxLength,
            &FileSysFlags,
            FileSysName,
            256))
    {
        GetDiskFreeSpace (
            Volume,
            &SectorsPerCluster,
            &BytesPerSector,
            &NumberOfFreeClusters,
            &TotalNumberOfClusters);
 
    sprintf (str,
        "\t## VOLUME %s INFO\n Name : %s\n Serial number : %p\n File system : %s\n",
        Volume,Name,SerialNumber,FileSysName);
    //printf(str);
    sprintf(str,
"%s SectorsPerCluster :\t%d\n BytesPerSector :\t%d\n NumberOfFreeClusters :\t%d\n TotalNumberOfClusters : \t%d\n",
  str,SectorsPerCluster,BytesPerSector,NumberOfFreeClusters,TotalNumberOfClusters);
     }
     else
         sprintf (str,"\t## WRONG VOLUME NAME OR NOT READY!");
     printf(str);
}
 
void SetWndIco(int index)
{
    char chBuffer[MAX_PATH];   
    GetSystemDirectory(chBuffer,MAX_PATH);
    sprintf(chBuffer,"%s%s",chBuffer,"\\shell32.dll");
    int nIcons = (int)ExtractIconEx(chBuffer, -1, NULL, NULL, 0);
    if(index < nIcons&&-1 < index)
    {
        HICON hIcon = ExtractIcon(NULL,chBuffer,index);
        GetConsoleTitle(chBuffer, MAX_PATH);
        HWND hWnd = FindWindow(NULL,chBuffer);
        SendMessage(hWnd,WM_SETICON,ICON_SMALL,(LPARAM) hIcon);
        ::SetWindowText(hWnd,"ListDrives.exe Created by Y.Lozitski");
    }
}

#include <windows.h>
#include <stdio.h>
#include <conio.h>
// чтобы получить результат в Kb, используем делитель.
#define DIV 1024
// #define DIV 1
char *divisor = "K";
// char *divisor = "";
// Ширина поля, в которой будут печаться цифры
// "%*ld" преобразует аргумент списка в int, и выравнивает вправо.
#define WIDTH 7
 
void main(int argc, char *argv[]){
  MEMORYSTATUS stat;
  GlobalMemoryStatus (&stat);
 
  printf ("The MemoryStatus structure is %ld bytes long.\n",
          stat.dwLength);
  printf ("It should be %d.\n", sizeof (stat));
  printf ("%ld percent of memory is in use.\n",
          stat.dwMemoryLoad);
  printf ("There are %*d total %sbytes of physical memory.\n",
          WIDTH, stat.dwTotalPhys/DIV, divisor);
  printf ("There are %*d free %sbytes of physical memory.\n",
          WIDTH, stat.dwAvailPhys/DIV, divisor);
  printf ("There are %*d total %sbytes of paging file.\n",
          WIDTH, stat.dwTotalPageFile/DIV, divisor);
  printf ("There are %*d free %sbytes of paging file.\n",
          WIDTH, stat.dwAvailPageFile/DIV, divisor);
  printf ("There are %*d total %sbytes of virtual memory.\n",
          WIDTH, stat.dwTotalVirtual/DIV, divisor);
  printf ("There are %*d free %sbytes of virtual memory.\n",
          WIDTH, stat.dwAvailVirtual/DIV, divisor);
  getch();
}