C / C++ / MFC

leon de boer wrote:

As they said you can't hack it and is guaranteed to perform error-free, that isn't a claim it's a provable fact.

ForNow wrote:

I have been using SendMessage for interprocess communication.

ForNow wrote:

and later tried RegisterWindowMessage

ForNow wrote:

I orignally a WM_USER + X

BOOL YourClass::AttachInput(HWND hwnd, BOOL fAttach)
{
  DWORD dwThreadId = GetWindowThreadProcessId(hwnd, NULL);
  DWORD dwMyThread = GetCurrentThreadId();
  return AttachThreadInput(dwMyThread, dwThreadId, fAttach);
}

ForNow wrote:

I would have to create a message pump via GetMessage,TranslateMessage,DispatchMessage

ForNow wrote:

Second What Makes SendMessage with WM_COPYDATA message so special that it is Sanctioned
By MicroSoft

// Post off message back to application window.
PostMessage(watchData->AppWindow, watchData->MsgId, watchData->CmdId, (LPARAM)msgToApp);

WNDPROC ConsoleWindow = NULL;

static LRESULT CALLBACK MyWndProc(HWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam) {

	// Process your message here

	if (ConsoleWindow)
		return CallWindowProc(ConsoleWindow, Wnd, Msg, wParam, lParam);   // Call back old handler
	return(0);
}

// Usually first thing in main
    HWND hWnd = GetConsoleWindow();
    ConsoleWindow = (WNDPROC)SetWindowLong(hWnd, GWL_WNDPROC, (LONG)MyWndProc);

#include <windows.h>
#include <tchar.h>

int APIENTRY WinMain(HINSTANCE hInstance,
	HINSTANCE hPrevInstance,
	LPSTR     lpCmdLine,
	int       nCmdShow)
{
	DWORD charsRead = 0;
	TCHAR keyBuffer[100];

	AllocConsole();

	HANDLE myConsoleHandle = GetStdHandle(STD_OUTPUT_HANDLE);
	DWORD cCharsWritten;
	TCHAR* str = TEXT("Hello I am the console\r\n");
	WriteConsole(myConsoleHandle, str, _tcslen(str), &cCharsWritten, NULL);
	HANDLE myConsoleHandleInput = GetStdHandle(STD_INPUT_HANDLE);
	ReadConsole(myConsoleHandleInput, keyBuffer, _countof(keyBuffer), &charsRead, NULL);
	
	str = TEXT("Okay lets mix it up with messages and console .. any key to exit\r\n");
	WriteConsole(myConsoleHandle, str, _tcslen(str), &cCharsWritten, NULL);
	DWORD events = 0;					// how many events took place
	INPUT_RECORD input_record = { 0 };	// a record of input events
	MSG Msg = { 0 };

	do {
		Msg.message = 0;
		input_record.EventType = 0;
		BOOL peek = PeekConsoleInput(myConsoleHandleInput, &input_record, 1, &events); // Peek for console input
		if (peek == FALSE) {										// No console input so do windows messages		
			if (PeekMessage(&Msg, 0, 0, 0, PM_REMOVE)) {			// Peek windows message
				TranslateMessage(&Msg);								// Translate each windows message
				DispatchMessage(&Msg);								// Dispatch each window message
			}
		} else {
			// We need to clear the console event we peeked .. we want next one
			ReadConsoleInput(myConsoleHandleInput,	&input_record, 1, &events);
		}
	} while ((Msg.message != WM_QUIT) && (input_record.EventType != KEY_EVENT));
}

SMD111 wrote:

Q: What is the effect of repetitive calls to this function? For example, I decide to change the key length, and generate a call with a different dwFlags value. What happens to the old key pair? Does it get overwritten? Or does each new call generate a new key pair?

SMD111 wrote:

MSDN: “The CryptGetUserKey function retrieves a handle of one of a user's two public/private key pairs.”
Q: which one?

SMD111 wrote:

Q: So how does one retrieve the public key, and how does one get the private key?

SMD111 wrote:

Q: How can the public/private key pair be destroyed?

char MyArray[Range + 1];   // 1

// ...
    Ptr_str = malloc(sizeof(MyArray));  // 2
    Ptr_str = MyArray;  // 3
    return(Ptr_str);

1. You cannot allocate an array on the stack using a variable value.

int RandomInt = rand() & 26;

MyArray[i] = StringsToChooseFrom[RandomInt -1];

Quote:

The rand() function returns a pseudo-random integer in the range 0 to RAND_MAX inclusive.

srand(time(NULL));

_TCHAR *ReturnRandomString( int Range )
{	
    _TCHAR *Ptr_str = (_TCHAR *) malloc(Range + 1);
    int i;
    
    for (i = 0; i < Range; i++)
    {
        int RandomInt = rand() % 26;
	
        Ptr_str[i] = (_TCHAR) (RandomInt + 97);
    }
	
    Ptr_str[i] = _T('\0');
	
    return Ptr_str;
}
...
srand(time(NULL));
    
_TCHAR *PtrCharArray = ReturnRandomString(5);
_tprintf(_T("String Array returned: %s\n"), PtrCharArray);
free(PtrCharArray);

_TCHAR *Ptr_str = (_TCHAR *) malloc(Range + 1);

Ptr_str[i] = (_TCHAR) (RandomInt + 97);

static _TCHAR const chars[] = _T("abcdefghijklmnopqrstuvwxyz");

TCHAR *Ptr_str = (_TCHAR *) malloc((sizeof(_TCHAR)*(Range + 1));

...
Ptr_str[i] = chars[RandomInt];

char *ReturnRandomString(int Range)
{

    char StringsToChooseFrom[26] = {'q','w','e','r','t','y','u','i','o','p','a','s','d','f','g','h','j','k','l','z','x','c','v','b','n','m'};
    char MyArray[100] = {}; // char MyArray[Range + 1];
    char *Ptr_str;
    int i;

    for(i = 0; i < Range; i++)
    {
        int RandomInt = rand() % 26; // int RandomInt = rand() & 26;

        MyArray[i] = StringsToChooseFrom[RandomInt];
    }
    MyArray[i + 1] = '\0';

    Ptr_str = (char*)malloc(sizeof(MyArray)); // Ptr_str = malloc(sizeof(MyArray));
    strcpy(Ptr_str, MyArray ); //	Ptr_str = MyArray;
    return(Ptr_str);
}


int _tmain(int argc, _TCHAR* argv[])
{

    srand(time(NULL)); // Moved out from function.
    for( int i = 0; i < 10; i++ )
    {
        char *PtrCharArray = ReturnRandomString(i);
        printf("\nString Array returned: %s\n", PtrCharArray);
    }
    return 0;
}

Krishnakumartg wrote:

MyArray[i + 1] = '\0';