Ограничение ввода

#include <iostream>
#include <conio.h>
#include <Windows.h>
#include <cctype>
#include <ctime>
using namespace std;
char *UserPassword(char*);
int numbers();
int casse();
//int Brootforce(*char);
char *CheckPass(*char, int, int);
int main(){
char stroka[4];
SetConsoleCP(1251);
SetConsoleOutputCP(1251);
cout << "\t\t***Установление ограничений для пароля:***\n\n";
int casses = casse();
int number = numbers();
system("cls");
UserPassword(stroka);
cout << "\t\tПроцесс проверки пароля. Все отключеные параметры будут заменены пробелами\n\n";
system("pause");
CheckPass(,casses,number);
system("pause");
system("cls");
unsigned int startTime = clock();
//Brootforce(YouPass);
unsigned int endTime = clock();
unsigned int endingTime = endTime - startTime;
cout << "Пароль подобран за " << endingTime << " секунд и с " << " попытки!\n\n\n";
system("pause");
return 0;
}
char *UserPassword(char *string){
cout << "Введите пароль пользователя(Не более 4-ох символов на английском): ";
cin.getline(string,4);
return string;
}
int casse(){
int imp = 0;
cout << "Наличие символов верхнего регистра(1(yes)/0(no)): ";
while((imp != 0) || (imp != 1) || !(cin >> imp)){
cin.clear();
while(cin.get() != '\n');
cout << "Ошибка! Наличие символов верхнего регистра(1(yes)/0(no)): ";
}
return imp;
}
int numbers(){
int imp = 0;
cout << "Наличие цифр(1(yes)/0(no)): ";
while((imp != 0) || (imp != 1) || !(cin >> imp)){
cin.clear();
while(cin.get() != '\n');
cout << "Ошибка! Наличие цифр(1(yes)/0(no)): ";
}
return imp;
}
/*char *CheckPass(char *string, int casses, int numbers){
for()
return string;
}
int Brootforce(char *string){
 
return a;
}
*/

/** @file
 *  @brief  Загаловочный файл модуля отправки сообщений о нажатии клавиш.
 *          Загаловочный файл модуля отправки сообщений о нажатии клавиш
 *          для консольных приложений под Windows
 */
#ifndef KEYNOTIFIER_WIN_H
#define KEYNOTIFIER_WIN_H
#include "../common/common.h"
 
#ifdef Q_OS_WIN32
#include "windows.h"
#include "keylayouttid.h"
#include "../common/events.h"
 
 
//#define ISUNICODEKEYCHAR
//#define ISDEBUGKEYHOOK
#define USECONHOSTTHREADID
 
/// @class TWinKeyNotifier
/// @brief Класс для отправке событий о нажатии клавиш
class TWinKeyNotifier : public QObject
{
    Q_OBJECT
public:
    /// @brief Инициаллизая.
    /// Инициаллизая.,а при повторном вызове переинициаллизирует
    /// Окно сообщений
    static void InitKeyNotifier(QObject *aMW, short *result);
    /// Прекращение уведомления о нажатие клавиши.
    static void Finit();
private:
    TWinKeyNotifier() {}
    TWinKeyNotifier(const TWinKeyNotifier &);
    TWinKeyNotifier& operator=(const TWinKeyNotifier&);
    // ---------------------
    static void UpdateKeyState(BYTE *keystate, int keycode);
    /// Клавиатурный хук
    // Более QT-шный вариант хука изложен здесь:
    // http://qt-project.org/forums/viewthread/12362
    // но он требует проверки на пригодность
    static LRESULT CALLBACK MyLowLevelKeyBoardProc(int nCode,
                                            WPARAM wParam,
                                            LPARAM lParam);
    /// Объект отправки событий о нажатии клавиши
    static QObject * MW;
    /// Идентификатор хука
    static HHOOK hHook;
    /// Идентификатор потока для получения индекса текущей раскладки
    static DWORD keythreadid;
    /// Флаг инициаллизации
    static bool isInited;
    /// Идентификатор текущего (консольного) окна
    static HWND CurrentWND;
};
 
#endif
#endif // KEYNOTIFIER_WIN_H

/** @file
 *      Модуль отправки сообщений о нажатии клавиш для
 *      консольных приложений под Windows
 */
#include "keynotifier_win.h"
#include "keynotifier.h"
#ifdef Q_OS_WIN32
 
QObject * TWinKeyNotifier::MW;
HHOOK TWinKeyNotifier::hHook;
DWORD TWinKeyNotifier::keythreadid;
bool  TWinKeyNotifier::isInited = false;
HWND TWinKeyNotifier::CurrentWND;
// Инициаллизая, а при повторном вызове переинициаллизирует
// Окно сообщений
void TWinKeyNotifier::InitKeyNotifier(QObject *aMW,short  int *result)
{
    //-------переменные для получения идентификатора потока ------------
    // keythreadidindex = 1 - это я так понимаю экспериментально установлено.
    const unsigned char keythreadidindex = 1;
    TPidList *  pconpidList;
    TTidList *  pcontidList;
    DWORD conhost_count = 0;
    DWORD threads_count = 0;
    DWORD currentpid;
    DWORD parentpid;
    *result = ke_noerror;
    if (!isInited)
    {
        keythreadid = 0;
        hHook = NULL;
        MW = aMW;
    }
    else
    {
        *result = ke_unknown;
        MW = aMW;
    }
    //----------------------
#ifdef USECONHOSTTHREADID
    if ((*result == ke_noerror) && (!isInited))
    {
        *result = InitNativeAPI(true);
        if (*result != ke_noerror)
        {
            // Для избежания совпадений кодов ошибок
            // *result -= 3;
            switch (*result)
            {
                case le_lidfailure:
                {
                    *result = ke_lidfailure;
                    break;
                }
                case le_procfailure:
                {
                    *result = ke_procfailure;
                    break;
                }
                case le_privfalure:
                {
                    *result = ke_privfalure;
                    break;
                }
            }
        }
    }
    if ((*result == ke_noerror) && (!isInited))
    {
        pconpidList = new TPidList;
        pcontidList = new TPidList;
        parentpid = 0;
        currentpid = GetCurrentProcessId();
        conhost_count = FindConHost(pconpidList);        
        if (conhost_count > 0)
        {
            parentpid = GetRelevantPID(pconpidList,conhost_count,currentpid);
            threads_count = GetThreadList(pcontidList,parentpid);
            if (threads_count >0)
            {
                keythreadid = (*pcontidList)[keythreadidindex];
            }
            else
            {
                *result = ke_tidfailure;
            }
        }
        else
        {
            *result = ke_pidfailure;
        }
        free(pconpidList);
        free(pcontidList);
    }
#endif
    //Хук создаёться ПОСЛЕ нахождения идентификатора потока
    if ((*result == ke_noerror) && (hHook == NULL))
    {
        // Получить идентификатор текущего глобального окна
        // для фильтрации нажатий клавишь из других окон
        CurrentWND = GetConsoleWindow();
        hHook = SetWindowsHookEx(WH_KEYBOARD_LL,
                                 MyLowLevelKeyBoardProc,
                                 NULL,
                                 0);
        if (hHook == NULL)
        {
            *result = ke_hookfailure;
        }
    }
    if ((!isInited) && (*result == ke_noerror))
    {
        isInited = true;
    }
}
 
void TWinKeyNotifier::Finit()
{
    isInited = false;
    UnhookWindowsHookEx(hHook);
    MW = NULL;
 
}
 
// Служебная функция определения состояния клавиш
void TWinKeyNotifier::UpdateKeyState(BYTE *keystate, int keycode)
{
    keystate[keycode] = GetKeyState(keycode);
}
 
// Клавиатурный хук(крюк)
LRESULT CALLBACK TWinKeyNotifier::MyLowLevelKeyBoardProc(int nCode,
                                        WPARAM wParam,
                                        LPARAM lParam)
{
// WPARAM is WM_KEYDOWn, WM_KEYUP, WM_SYSKEYDOWN, or WM_SYSKEYUP
// LPARAM is the key information
#define MAXKEYNAMESTRLNG 128
#ifdef ISUNICODEKEYCHAR
    static char lpszName[MAXKEYNAMESTRLNG] = {0};
    DWORD dwMsg = 1;
    static wchar_t buffer[2];
#endif
static BYTE keyboard_state[256];
static KBDLLHOOKSTRUCT cKey;
static HKL keyboard_layout;
WORD word;
THotKey hKey = {0};
HWND FocusWND;
 
    FocusWND = GetForegroundWindow();
    // Можно при необходимости отключить фильтрацию
    //CurrentWND = FWND;
    // Проверяем что это сообщение о нажатие клавиши
    // и что наше окно в фокусе.
    if ((wParam == WM_KEYDOWN) && (CurrentWND == FocusWND))
    {
        // Получение информации о клавиши
        cKey = *((KBDLLHOOKSTRUCT*)lParam);
 
        // Получение информации о состоянии клавиши
        GetKeyboardState(keyboard_state);
        UpdateKeyState(keyboard_state, VK_SHIFT);
        UpdateKeyState(keyboard_state, VK_CAPITAL);
        UpdateKeyState(keyboard_state, VK_CONTROL);
        UpdateKeyState(keyboard_state, VK_MENU);
 
        // Получение текущей раскладки клавиатуры:
        // Так как для консольных приложений под windows
        // определение раскладки сопряжено с использованием
        // нестандартного способа, который не гарантирует
        // результат то используеться американская раскладка
        #ifndef USECONHOSTTHREADID
            keyboard_layout = (HKL)0x0409;
        #else
            keyboard_layout = GetKeyboardLayout(keythreadid);
        #endif
        // Преобразование в Ascii
        #ifndef ISUNICODEKEYCHAR
        if (ToAsciiEx(cKey.vkCode,
                      cKey.scanCode,
                      &keyboard_state[0],
                      &word,
                      0,
                      keyboard_layout) == 0)
        {
            // Преобразование не удалось
            word = 0;
        }
        hKey.word = word;
        #else
        // Преобразование в Unicode (Опционально)
        if (ToUnicodeEx(cKey.vkCode,
                             cKey.scanCode,
                             &keyboard_state[0],
                (LPWSTR)&buffer, 1, 0, keyboard_layout) > 0)
        {
            hKey.word = buffer[0];
        }
        else
        {
            hKey.word = 0;
        }
        #endif
 
        // Вывод для отладки
        #ifdef ISDEBUGKEYHOOK
        // Получить имя клавиши
        dwMsg += cKey.scanCode << 16;
        dwMsg += cKey.flags << 24;
        if (GetKeyNameText(dwMsg, (LPTSTR)lpszName, MAXKEYNAMESTRLNG) != 0 )
        {
            // Print the output
            buffer[1] = L'\0';
            // Код используемый только при отладки
            //qDebug() << "Key Pressed!";
            //qDebug() << "Key: " << cKey.vkCode << " "
            //         << QString::fromUtf16((ushort*)buffer)
            //         << " " << QString::fromUtf16((ushort*)lpszName);
        }
        #else
        if (MW != NULL)
        {
            QCoreApplication::postEvent(MW,
                    new TK_KeyEvent(KEYPRESSED,hKey));
        }
        #endif
    }
    return CallNextHookEx(hHook, nCode, wParam, lParam);
}
 
 
#endif