os4

#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_LEN 255

void getSysInfo() {
    LPSYSTEM_INFO sysInfo = (LPSYSTEM_INFO)malloc(sizeof *sysInfo);
    GetSystemInfo(sysInfo);
    printf("Информация о системе:\n");
    switch(sysInfo -> wProcessorArchitecture) {
        case PROCESSOR_ARCHITECTURE_AMD64:
            printf("Процессор AMD или Intel x64\n");
            break;
        case PROCESSOR_ARCHITECTURE_ARM:
            printf("Процессор AMR\n");
            break;
        case PROCESSOR_ARCHITECTURE_IA64:
            printf("Процессор Intel Itanium-based\n");
            break;
        case PROCESSOR_ARCHITECTURE_INTEL:
            printf("Процессор x86\n");
            break;
        case PROCESSOR_ARCHITECTURE_UNKNOWN:
            printf("Процессор неизвестной архитектуры\n");
            break;
    }
    printf("Размер региона памяти: %ld\n", sysInfo -> dwPageSize);
    printf("Доступны адреса памяти от %p до %p\n", sysInfo -> lpMinimumApplicationAddress, sysInfo -> lpMaximumApplicationAddress);
    printf("Количество процессоров: %ld\n", sysInfo -> dwNumberOfProcessors);
    printf("\"Гранулярность\" выделения памяти: %ld\n", sysInfo -> dwAllocationGranularity);
}

void getMemoryStatus() {
    LPMEMORYSTATUSEX memStatus = (LPMEMORYSTATUSEX)malloc(sizeof *memStatus);
    memStatus -> dwLength = sizeof *memStatus;
    if (!GlobalMemoryStatusEx(memStatus))
        printf("Ошибка: код ошибки %ld\n", GetLastError());
    else {
        printf("Используется %ld процентов памяти\n", memStatus -> dwMemoryLoad);
        printf("Всего %I64d байт физической памяти\n", memStatus -> ullTotalPhys);
        printf("Всего %I64d байт свободной физической памяти\n", memStatus -> ullAvailPhys);
        printf("Всего %I64d байт файла подкачки \n", memStatus -> ullTotalPageFile);
        printf("Всего %I64d байт свободно в файле подкачки\n", memStatus -> ullAvailPageFile);
        printf("Всего %I64d байт виртуальной памяти\n", memStatus -> ullTotalVirtual);
        printf("Всего %I64d байт свободной виртуальной памяти\n", memStatus -> ullAvailVirtual);
    }
}

void getStateByAddress() {
    printf("Введите адрес участка памяти, состояние которого необходимо получить: ");
    LPVOID addr;
    if (scanf("%p", &addr)) {
        fflush(stdin);
        PMEMORY_BASIC_INFORMATION memInfo = (PMEMORY_BASIC_INFORMATION)malloc(sizeof *memInfo);
        if (!VirtualQuery(addr, memInfo, sizeof *memInfo)) {
            DWORD err = GetLastError();
            if (err == ERROR_INVALID_PARAMETER)
                printf("Ошибка: адрес недоступен данному процессу\n");
            else
                printf("Ошибка: код ошибки %ld\n", err);
        }
        else {
            printf("Адрес (округленный): %p\n", memInfo -> BaseAddress);
            printf("Адрес региона: %p\n", memInfo -> AllocationBase);
            printf("Доступ к региону памяти (при его резервировании): ");
            if (memInfo -> AllocationProtect & PAGE_EXECUTE)
                printf("исполнение\n");
            else if (memInfo -> AllocationProtect & PAGE_EXECUTE_READ)
                printf("исполнение и чтение\n");
            else if (memInfo -> AllocationProtect & PAGE_EXECUTE_READWRITE)
                printf("исполнение, чтение и запись\n");
            else if (memInfo -> AllocationProtect & PAGE_EXECUTE_WRITECOPY)
                printf("исполнение, чтение и копирование при записи\n");
            else if (memInfo -> AllocationProtect & PAGE_NOACCESS)
                printf("запрещен\n");
            else if (memInfo -> AllocationProtect & PAGE_READONLY)
                printf("только чтение\n");
            else if (memInfo -> AllocationProtect & PAGE_READWRITE)
                printf("чтение и запись\n");
            else if (memInfo -> AllocationProtect & PAGE_WRITECOPY)
                printf("чтение и копирование при записи\n");
            else if (memInfo -> AllocationProtect == 0)
                printf("нет доступа\n");
            else
                printf("неизвестно\n");
            printf("Размер региона: %I64d\n", memInfo -> RegionSize);
            switch(memInfo -> State) {
                case MEM_COMMIT:
                    printf("Память на страницах была выделена\n");
                    break;
                case MEM_FREE:
                    printf("Память на страницах свободна\n");
                    break;
                case MEM_RESERVE:
                    printf("Память на страницах зарезервирована\n");
                    break;
            }
            printf("Доступ к страницам: ");
            if (memInfo -> Protect & PAGE_EXECUTE)
                printf("исполнение\n");
            else if (memInfo -> Protect & PAGE_EXECUTE_READ)
                printf("исполнение и чтение\n");
            else if (memInfo -> Protect & PAGE_EXECUTE_READWRITE)
                printf("исполнение, чтение и запись\n");
            else if (memInfo -> Protect & PAGE_EXECUTE_WRITECOPY)
                printf("исполнение, чтение и копирование при записи\n");
            else if (memInfo -> Protect & PAGE_NOACCESS)
                printf("запрещен\n");
            else if (memInfo -> Protect & PAGE_READONLY)
                printf("только чтение\n");
            else if (memInfo -> Protect & PAGE_READWRITE)
                printf("чтение и запись\n");
            else if (memInfo -> Protect & PAGE_WRITECOPY)
                printf("чтение и копирование при записи\n");
            else if (memInfo -> Protect == 0)
                printf("нет доступа\n");
            else
                printf("неизвестно\n");
            switch(memInfo -> Type) {
                case MEM_IMAGE:
                    printf("Страницы могут быть использованы дргуими процессами через модуль\n");
                    break;
                case MEM_MAPPED:
                    printf("Страницы могут быть использованы другими процессами\n");
                    break;
                case MEM_PRIVATE:
                    printf("Страницы приватны\n");
                    break;
            }
        }
    }
    else {
        fflush(stdin);
        printf("Ошибка при считывании ввода\n");
    }
}

void regionReserveFree() {
    int flag = 1;
    do {
        printf("1 - Резервирование региона\n2 - Освобождение региона\n3 - Возврат в меню\n");
        char c = getchar();
        fflush(stdin);
        LPVOID addr;
        switch (c) {
            case '1':
                printf("Введите адрес участка памяти для резервирования и выделения памяти (для выделения в автоматическом режиме введите 0): ");
                scanf("%p", &addr);
                fflush(stdin);
                printf("Введите размер участка памяти для резервирования и выделения памяти: ");
                SIZE_T regSize;
                scanf("%I64d", &regSize);
                fflush(stdin);
                printf("Выполнить резервирование и выделение памяти одновременно или последовательно?\n1 - одновременно\n2 - последовательно\n");
                char c1 = getchar();
                fflush(stdin);
                LPVOID p;
                int flag1 = 1;
                do {
                    switch(c1) {
                        case '1':
                            p = VirtualAlloc(addr, regSize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
                            flag1 = 0;
                            break;
                        case '2':
                            p = VirtualAlloc(addr, regSize, MEM_RESERVE, PAGE_READWRITE);
                            if (p)
                                p = VirtualAlloc(p, regSize, MEM_COMMIT, PAGE_READWRITE);
                            flag1 = 0;
                            break;
                        default:
                            printf("Ошибка ввода, попробуйте еще раз\n");
                    }
                } while (flag1);
                printf("Реальный адрес, по которому выделена память: %p\n", p);
                if (!p) {
                    DWORD err = GetLastError();
                    if (err == ERROR_INVALID_ADDRESS)
                        printf("Ошибка: неправильный адрес\n");
                    else
                        printf("Ошибка: код ошибки %ld\n", err);
                }
                break;
            case '2':
                printf("Введите адрес участка памяти для освобождения: ");
                scanf("%p", &addr);
                fflush(stdin);
                if (!VirtualFree(addr, 0, MEM_RELEASE)) {
                    DWORD err = GetLastError();
                    if (err == ERROR_INVALID_ADDRESS)
                        printf("Ошибка: неправильный адрес\n");
                    else
                        printf("Ошибка: код ошибки %ld\n", err);
                }
                break;
            case '3':
                printf("Возвращаемся в меню\n");
                flag = 0;
                break;
            default:
                printf("Ошибка ввода, попробуйте еще раз\n");
        }
    } while (flag);
}

void writeDataByAddress() {
    printf("Введите адрес участка памяти, в который надо записать данные: ");
    LPVOID addr;
    scanf("%p", &addr);
    fflush(stdin);
    printf("Введите данные, которые хотите ввести по указанному адресу: ");
    char buf[MAX_LEN];
    if (fgets(buf, MAX_LEN, stdin)) {
        fflush(stdin);
        buf[strlen(buf) - 1] = '\0';
        LPVOID p = VirtualAlloc(addr, strlen(buf)*sizeof(char), MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
        if (p) {
            memcpy(p, buf, strlen(buf));
            printf("Реальный адрес, по которому переданы данные: %p\n", p);
        }
        else {
            DWORD err = GetLastError();
            if (err == ERROR_INVALID_ADDRESS)
                printf("Ошибка: неправильный адрес\n");
            else
                printf("Ошибка: код ошибки %ld\n", err);
        }
    }
    else {
        fflush(stdin);
        printf("Ошибка при считывании ввода\n");
    }
}

void setProtect() {
    printf("Введите адрес участка памяти для установки режима защиты: ");
    LPVOID addr;
    scanf("%p", &addr);
    fflush(stdin);
    printf("Введите размер участка памяти для установки режима защиты: ");
    SIZE_T regSize;
    scanf("%I64d", &regSize);
    fflush(stdin);
    DWORD oldProtect, newProtect;
    printf("Введите номер атрибута защиты, который хотите задать:\n"
            "1 - без доступа, 2 - только чтение, 3 - чтение и запись, 4 - исполнение, чтение и запись\n");
    char c = getchar();
    fflush(stdin);
    switch (c) {
        case '1':
            newProtect = PAGE_NOACCESS;
            break;
        case '2':
            newProtect = PAGE_READONLY;
            break;
        case '3':
            newProtect = PAGE_READWRITE;
            break;
        case '4':
            newProtect = PAGE_EXECUTE_READWRITE;
            break;
        default:
            printf("Ошибка ввода, попробуйте еще раз\n");
    }

    if (!VirtualProtect(addr, regSize, newProtect, &oldProtect)) {
        DWORD err = GetLastError();
        if (err == ERROR_INVALID_ADDRESS)
            printf("Ошибка: неправильный адрес\n");
        else
            printf("Ошибка: код ошибки %ld\n", err);
    }
    else {
        printf("Проверим с помощью функции VirtualQuery\n");
        PMEMORY_BASIC_INFORMATION memInfo = (PMEMORY_BASIC_INFORMATION)malloc(sizeof *memInfo);
        if (!VirtualQuery(addr, memInfo, sizeof *memInfo)) {
            DWORD err = GetLastError();
            if (err == ERROR_INVALID_PARAMETER)
                printf("Ошибка: адрес недоступен данному процессу\n");
            else
                printf("Ошибка: код ошибки %ld\n", err);
        }
        else {
            if (memInfo -> Protect == newProtect)
                printf("Успешно установлен атрибут защиты\n");
            else
                printf("Атрибут не был успешно установлен\n");
        }
    }
}

int main()
{
    int flag = 1;
    system("chcp 65001");
    do {
        printf("Добро пожаловать! Выберите действие:\n1 - Информация о вычислительной системе\n2 - Статус виртуальной памяти\n"
            "3 - Состояние участка памяти по адресу\n4 - Резервирование (и освобождение) региона и передача ему физической памяти\n"
            "5 - Запись данных в свободную ячейку памяти по адресу\n6 - Установка защиты доступа для заданного региона и ее проверка\n7 - Выход\n");
        char c = getchar();
        fflush(stdin);
        switch (c){
            case '1':
                getSysInfo();
                break;
            case '2':
                getMemoryStatus();
                break;
            case '3':
                getStateByAddress();
                break;
            case '4':
                regionReserveFree();
                break;
            case '5':
                writeDataByAddress();
                break;
            case '6':
                setProtect();
                break;
            case '7':
                printf("Выход из программы\n");
                flag = 0;
                break;
            default:
                printf("Неправильный ввод, попробуйте еще раз\n");
        }

    } while (flag);
    return 0;
}