windows-xp/Source/XPSP1/NT/inetsrv/msmq/sdk/samples/mqapitst/mainfrm.cpp

/* ************************************************************************ */
/*                                                                          */
/* Main file of the application MQ API test.                                */
/*                                                                          */
/* ************************************************************************ */

//
// MainFrm.cpp : implementation of the CMainFrame class
//
//=--------------------------------------------------------------------------=
// Copyright  1997-1999  Microsoft Corporation.  All Rights Reserved.
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
// PARTICULAR PURPOSE.
//=--------------------------------------------------------------------------=



#include "stdafx.h"
#include "MQApitst.h"
#include <afxtempl.h>

#include "MainFrm.h"
#include "CrQDlg.h"
#include "DelQDlg.h"
#include "OpenQDlg.h"
#include "ClosQDlg.h"
#include "SendMDlg.h"
#include "RecvMDlg.h"
#include "RecWDlg.h"
#include "LocatDlg.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

LPSTR UnicodeStringToAnsiString(LPCWSTR lpcsUnicode)
{
    LPSTR lpAnsiString = NULL;

    if (lpcsUnicode)
    {
        DWORD dwSize = wcstombs(NULL, lpcsUnicode, 0);
        lpAnsiString = new char[dwSize+1];
        size_t rc = wcstombs(lpAnsiString, lpcsUnicode, dwSize);
        ASSERT(rc != (size_t)(-1));
        lpAnsiString[dwSize] = '\0';
    }

    return lpAnsiString;
}

void AnsiStringToUnicode(LPWSTR lpsUnicode, LPSTR  lpsAnsi, DWORD  nSize)
{
    if (lpsUnicode == NULL)
    {
        return;
    }

    ASSERT(lpsAnsi != NULL);

    size_t rc = mbstowcs(lpsUnicode, lpsAnsi, nSize);
    ASSERT(rc != (size_t)(-1));
    if (lpsUnicode[nSize-1] != L'\0')
        lpsUnicode[nSize] = L'\0';
}

#ifdef UNICODE
#define _mqscpy(dest, src)  wcscpy(dest, src)
#else
#define _mqscpy(dest, src)  AnsiStringToUnicode(dest, src, _tcslen(src)+1)
#endif

BOOL GetTextualSid(
    PSID pSid,          // binary SID
    LPTSTR TextualSID,   // buffer for textual representation of SID
    LPDWORD dwBufferLen // required/provided TextualSid buffersize
    )
{
    PSID_IDENTIFIER_AUTHORITY psia;
    DWORD dwSubAuthorities;
    DWORD dwSidRev=SID_REVISION;
    DWORD dwCounter;
    DWORD dwSidSize;

    // obtain SidIdentifierAuthority
    psia=&((SID *)pSid)->IdentifierAuthority;

    // obtain sidsubauthority count
    dwSubAuthorities=(DWORD)((SID *)pSid)->SubAuthorityCount;

    //
    // compute buffer length
    // S-SID_REVISION- + identifierauthority- + subauthorities- + NULL
    //
    dwSidSize = (15 + 12 + (12 * dwSubAuthorities) + 1) * sizeof(TCHAR);

    //
    // check provided buffer length.
    // If not large enough, indicate proper size and setlasterror
    //
    if (*dwBufferLen < dwSidSize)
    {
        *dwBufferLen = dwSidSize;
        SetLastError(ERROR_INSUFFICIENT_BUFFER);
        return FALSE;
    }

    //
    // prepare S-SID_REVISION-
    //
    TextualSID += _stprintf(TextualSID, TEXT("S-%lu-"), dwSidRev );

    //
    // prepare SidIdentifierAuthority
    //
    if ( (psia->Value[0] != 0) || (psia->Value[1] != 0) )
    {
        TextualSID += _stprintf(TextualSID,
                    TEXT("0x%02hx%02hx%02hx%02hx%02hx%02hx"),
                    (USHORT)psia->Value[0],
                    (USHORT)psia->Value[1],
                    (USHORT)psia->Value[2],
                    (USHORT)psia->Value[3],
                    (USHORT)psia->Value[4],
                    (USHORT)psia->Value[5]);
    }
    else
    {
        TextualSID += _stprintf(TextualSID, TEXT("%lu"),
                    (ULONG)(psia->Value[5]      )   +
                    (ULONG)(psia->Value[4] <<  8)   +
                    (ULONG)(psia->Value[3] << 16)   +
                    (ULONG)(psia->Value[2] << 24)   );
    }

    //
    // loop through SidSubAuthorities
    //
    for (dwCounter=0 ; dwCounter < dwSubAuthorities ; dwCounter++)
    {
        TextualSID += _stprintf(TextualSID, TEXT("-%lu"),
                    ((SID *)pSid)->SubAuthority[ dwCounter] );
    }

    return TRUE;
}

/////////////////////////////////////////////////////////////////////////////
// CMainFrame

IMPLEMENT_DYNCREATE(CMainFrame, CFrameWnd)

BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)
   //{{AFX_MSG_MAP(CMainFrame)
   ON_WM_CREATE()
   ON_COMMAND(ID_API_CREATE_QUEUE, OnApiCreateQueue)
   ON_COMMAND(ID_API_DELETE_QUEUE, OnApiDeleteQueue)
   ON_COMMAND(ID_API_OPEN_QUEUE, OnApiOpenQueue)
   ON_COMMAND(ID_API_CLOSE_QUEUE, OnApiCloseQueue)
   ON_COMMAND(ID_API_SEND_MESSAGE, OnApiSendMessage)
   ON_COMMAND(ID_API_RECEIVE_MESSAGE, OnApiReceiveMessage)
   ON_COMMAND(ID_API_LOCATE, OnApiLocate)
   //}}AFX_MSG_MAP
END_MESSAGE_MAP()

static UINT indicators[] =
{
   ID_SEPARATOR,           // status line indicator
   ID_INDICATOR_CAPS,
   ID_INDICATOR_NUM,
   ID_INDICATOR_SCRL,
};

/////////////////////////////////////////////////////////////////////////////
// CMainFrame construction/destruction

CMainFrame::CMainFrame()
{
   // TODO: add member initialization code here.
}

CMainFrame::~CMainFrame()
{
}

int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
    if (CFrameWnd::OnCreate(lpCreateStruct) == -1)
        return -1;

    if (!m_wndToolBar.Create(this) ||
        !m_wndToolBar.LoadToolBar(IDR_MAINFRAME))
    {
        TRACE0("Failed to create toolbar\n");
        return -1;      // fail to create
    }

    if (!m_wndStatusBar.Create(this) ||
        !m_wndStatusBar.SetIndicators(indicators,
        sizeof(indicators)/sizeof(UINT)))
    {
        TRACE0("Failed to create status bar\n");
        return -1;      // fail to create
    }

    // TODO: Remove this if you don't want tool tips or a resizeable toolbar
    m_wndToolBar.SetBarStyle(m_wndToolBar.GetBarStyle() |
        CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC);

    // TODO: Delete these three lines if you don't want the toolbar to
    //  be dockable
    m_wndToolBar.EnableDocking(CBRS_ALIGN_ANY);
    EnableDocking(CBRS_ALIGN_ANY);
    DockControlBar(&m_wndToolBar);

    return 0;
}

BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
{
    // TODO: Modify the Window class or styles here by modifying
    //  the CREATESTRUCT cs

    return CFrameWnd::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CMainFrame diagnostics

#ifdef _DEBUG
void CMainFrame::AssertValid() const
{
    CFrameWnd::AssertValid();
}

void CMainFrame::Dump(CDumpContext& dc) const
{
    CFrameWnd::Dump(dc);
}

#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CMainFrame message handlers

#define MAXINDEX 31


/* ************************************************************************ */
/*                        RemoveFromPathNameArray                           */
/* ************************************************************************ */
/* This function goes through the PathName Array and compares the given     */
/* PathName to the PathName's of the items in the array.                    */
/* If a match is found the item is removed from the array and the function  */
/* returns a pointer to the item, otherwise a NULL pointer is returned.     */
/* ************************************************************************ */
ARRAYQ* CMainFrame::RemoveFromPathNameArray(TCHAR szPathName[MAX_Q_PATHNAME_LEN])
{
    int Index;
    int MaxIndex = m_PathNameArray.GetSize();
    ARRAYQ* pQueue;

    //
    // Loop through the PathName array.
    //
    for (Index=0; Index<MaxIndex; Index++)
    {
        if (_tcscmp(szPathName, m_PathNameArray[Index]->szPathName) == 0)
        {
            //
            // Found a match.
            //
            pQueue = m_PathNameArray[Index];
            m_PathNameArray.RemoveAt(Index);
            return pQueue;
        }
    }
    return NULL; // ERROR - no match was found.
}

/* ************************************************************************ */
/*                             CleanPathNameArray                           */
/* ************************************************************************ */
/* This function goes through the PathName array and deletes all the items  */
/* in it. the function frees the allocated memory.                          */
/* ************************************************************************ */
void CMainFrame::CleanPathNameArray()
{
    ARRAYQ* pQueue;

    while (m_PathNameArray.GetSize() > 0)
    {
        pQueue = m_PathNameArray[0];
        m_PathNameArray.RemoveAt(0);
        delete pQueue;
    }
}

/* ************************************************************************ */
/*                        RemoveFromOpenedQueuePathNameArray                */
/* ************************************************************************ */
/* This function goes through the OpenedPathName Array and compares the     */
/* given PathName to the PathName's of the items in the array.              */
/* If a match is found the item is removed from the array and the function  */
/* returns a pointer to the item, otherwise a NULL pointer is returned.     */
/* ************************************************************************ */
ARRAYQ* CMainFrame::RemoveFromOpenedQueuePathNameArray(TCHAR szPathName[MAX_Q_PATHNAME_LEN])
{
    int Index;
    int MaxIndex = m_OpenedQueuePathNameArray.GetSize();
    ARRAYQ* pQueue;

    //
    // Loop through the OpenedPathName array.
    //
    for (Index=0; Index<MaxIndex; Index++)
    {
        if (_tcscmp(szPathName, m_OpenedQueuePathNameArray[Index]->szPathName) == 0)
        {
            //
            // Found a match.
            //
            pQueue = m_OpenedQueuePathNameArray[Index];
            m_OpenedQueuePathNameArray.RemoveAt(Index);
            return pQueue;
        }
    }
    return NULL; // ERROR - no match was found.
}

/* ************************************************************************ */
/*                           IsOpenedQueueArrayEmpty                        */
/* ************************************************************************ */
/* This function checks if the size of the OpenedPathName array is zero or  */
/* less and if so it returns TRUE otherwise it returns FALSE.               */
/* ************************************************************************ */
BOOL CMainFrame::IsOpenedQueueArrayEmpty()
{
    if (m_OpenedQueuePathNameArray.GetSize() <= 0)
    {
        return TRUE;
    }
    else
    {
        return FALSE;
    }
}

/* ************************************************************************ */
/*                        MoveToOpenedQueuePathNameArray                    */
/* ************************************************************************ */
/* This function moves an item from the PathName array to the               */
/* OpenedPathName array. also it updates the hadle and the access rights    */
/* to the moved queue.                                                      */
/* ************************************************************************ */
void CMainFrame::MoveToOpenedQueuePathNameArray(TCHAR szPathName[MAX_Q_PATHNAME_LEN],
                                                QUEUEHANDLE hQueue, DWORD dwAccess)
{
    ARRAYQ* pQueue;

    pQueue = RemoveFromPathNameArray(szPathName);
    pQueue->hHandle = hQueue;                     // add Queue Handle.
    pQueue->dwAccess = dwAccess;                  // add Queue Access rights.
    Add2OpenedQueuePathNameArray(pQueue);
}

/* ************************************************************************ */
/*                              MoveToPathNameArray                         */
/* ************************************************************************ */
/* This function moves an item from the OpenedPathName array to the         */
/* PathName array.                                                          */
/* ************************************************************************ */
void CMainFrame::MoveToPathNameArray(TCHAR szPathName[MAX_Q_PATHNAME_LEN])
{
    ARRAYQ* pQueue;

    pQueue = RemoveFromOpenedQueuePathNameArray(szPathName);
    Add2PathNameArray(pQueue);
}

/* ************************************************************************ */
/*                             UpdatePathNameArrays                         */
/* ************************************************************************ */
/* This function goes through the Opened Queue PathName array and for every */
/* item in it, it checkes if the item is found in the PathName array as     */
/* well, if so the function removes the item from the PathName array.       */
/* ************************************************************************ */
void CMainFrame::UpdatePathNameArrays()
{
    int PathNameIndex;
    int OpenedPathNameIndex;
    int MaxPathNameIndex = m_PathNameArray.GetSize();
    int MaxOpenedPathNameIndex = m_OpenedQueuePathNameArray.GetSize();
    ARRAYQ* pQueue;

    //
    // Loop through the OpenedPathName array.
    //
    for (OpenedPathNameIndex=0; OpenedPathNameIndex<MaxOpenedPathNameIndex; OpenedPathNameIndex++)
    {
        for (PathNameIndex=0; PathNameIndex<MaxPathNameIndex; PathNameIndex++)
        {
            if (_tcscmp(m_OpenedQueuePathNameArray[OpenedPathNameIndex]->szPathName,
                m_PathNameArray[PathNameIndex]->szPathName) == 0)
            {
                //
                // Found a match, remove it from PathName Array.
                //
                pQueue = m_PathNameArray[PathNameIndex];
                m_PathNameArray.RemoveAt(PathNameIndex);
                delete pQueue;
                //
                // get out of inner for loop.
                //
                break;
            }
        }
    }
}


/* ************************************************************************ */
/*                              GetQueueHandle                              */
/* ************************************************************************ */
/* This function goes through the OpenedPathName array and retrieve the     */
/* Handle to the queue which matches the given PathName. If no match was    */
/* found the function returns FALSE.                                        */
/* ************************************************************************ */
BOOL CMainFrame::GetQueueHandle(TCHAR szPathName[MAX_Q_PATHNAME_LEN],
                                QUEUEHANDLE* phClosedQueueHandle)
{
    int Index;
    int MaxIndex = m_OpenedQueuePathNameArray.GetSize();
    ARRAYQ* pQueue;

    //
    // Loop through the OpenedPathName array.
    //
    for (Index=0; Index<MaxIndex; Index++)
    {
        if (_tcscmp(szPathName, m_OpenedQueuePathNameArray[Index]->szPathName) == 0)
        {
            //
            // Found a match.
            //
            pQueue = m_OpenedQueuePathNameArray[Index];
            *phClosedQueueHandle = pQueue->hHandle;
            return TRUE;
        }
    }
    return FALSE; // ERROR - no match was found.
}

/* ************************************************************************ */
/*                       TranslatePathNameToFormatName                      */
/* ************************************************************************ */
/* This function goes through the PathName array and retrieve the           */
/* FormatName to the queue which matches the given PathName. If no match    */
/* was found the function returns FALSE.                                    */
/* ************************************************************************ */
BOOL CMainFrame::TranslatePathNameToFormatName(TCHAR szPathName[MAX_Q_PATHNAME_LEN],
                                               TCHAR szFormatName[MAX_Q_FORMATNAME_LEN])
{
    int Index;
    int MaxIndex = m_PathNameArray.GetSize();
    ARRAYQ* pQueue;

    //
    // Loop through the PathName array.
    //
    for (Index=0; Index<MaxIndex; Index++)
    {
        if (_tcscmp(szPathName, m_PathNameArray[Index]->szPathName) == 0)
        {
            //
            // Found a match.
            //
            pQueue = m_PathNameArray[Index];
            _tcsncpy (szFormatName, pQueue->szFormatName, MAX_Q_FORMATNAME_LEN);
            return TRUE;
        }
    }
    return FALSE; // ERROR - no match was found.
}

/* ************************************************************************ */
/*                  TranslateOpenedQueuePathNameToFormatName                */
/* ************************************************************************ */
/* This function goes through the OpenedPathName array and retrieve the     */
/* FormatName to the queue which matches the given PathName. If no match    */
/* was found the function returns FALSE.                                    */
/* ************************************************************************ */
BOOL CMainFrame::TranslateOpenedQueuePathNameToFormatName(
    TCHAR szPathName[MAX_Q_PATHNAME_LEN],
    TCHAR szFormatName[MAX_Q_FORMATNAME_LEN]
    )
{
    int Index;
    int MaxIndex = m_OpenedQueuePathNameArray.GetSize();
    ARRAYQ* pQueue;

    //
    // Loop through the OpenedPathName array.
    //
    for (Index=0; Index<MaxIndex; Index++)
    {
        if (_tcscmp(szPathName, m_OpenedQueuePathNameArray[Index]->szPathName) == 0)
        {
            //
            // Found a match.
            //
            pQueue = m_OpenedQueuePathNameArray[Index];
            _tcsncpy (szFormatName, pQueue->szFormatName, MAX_Q_FORMATNAME_LEN);
            return TRUE;
        }
    }
    return FALSE; // ERROR - no match was found.
}


/* ************************************************************************ */
/*                         DisplayPathNameArray                             */
/* ************************************************************************ */
/* This function goes through the PathName Array and prints it to screen.   */
/* ************************************************************************ */
void CMainFrame::DisplayPathNameArray()
{
    int Index;
    int MaxIndex = m_PathNameArray.GetSize();
    TCHAR szMsgBuffer[BUFFERSIZE];

    _stprintf(szMsgBuffer, TEXT("   Located Queues Path Name :"));
    PrintToScreen(szMsgBuffer);
    //
    // Loop through the PathName array.
    //
    for (Index=0; Index<MaxIndex; Index++)
    {
        //
        // Print the PathNames.
        //
        _stprintf(szMsgBuffer, TEXT("\t%d. %s"),Index+1, m_PathNameArray[Index]->szPathName);
        PrintToScreen(szMsgBuffer);
    }
}

/* ************************************************************************ */
/*                    DisplayOpenedQueuePathNameArray                       */
/* ************************************************************************ */
/* This function goes through the Opened Queues PathName Array and          */
/* prints it to screen.                                                     */
/* ************************************************************************ */
void CMainFrame::DisplayOpenedQueuePathNameArray()
{
    int Index;
    int MaxIndex = m_OpenedQueuePathNameArray.GetSize();
    TCHAR szMsgBuffer[BUFFERSIZE];

    _stprintf(szMsgBuffer, TEXT("   Currently Opened Queues Path Names:"));
    PrintToScreen(szMsgBuffer);
    //
    // Loop through the OpenedQueuePathName array.
    //
    for (Index=0; Index<MaxIndex; Index++)
    {
        //
        // Print the PathNames.
        //
        _stprintf(szMsgBuffer, TEXT("\t%d. %s"),Index+1, m_OpenedQueuePathNameArray[Index]->szPathName);
        PrintToScreen(szMsgBuffer);
    }
}

/* ************************************************************************ */
/*                          GetMsgClassStatus                               */
/* ************************************************************************ */
/* This function sets proper status string based on a given MQMSG class.    */
/* ************************************************************************ */

struct
{
	unsigned short	mclass;
	LPTSTR          pszDescription;
} StringClass[] =
  {
	{ MQMSG_CLASS_NORMAL, TEXT("The Message was received successfully.")},
	{ MQMSG_CLASS_ACK_REACH_QUEUE, TEXT("The REACH QUEUE ACK Message was read successfully.")},
	{ MQMSG_CLASS_ACK_RECEIVE, TEXT("The RECEIVE ACK Message was read successfully.")},
	{ MQMSG_CLASS_NACK_BAD_DST_Q, TEXT("The DESTINATION QUEUE HANDLE INVALID Nack Message was read successfully.")},
	{ MQMSG_CLASS_NACK_RECEIVE_TIMEOUT, TEXT("The TIME TO RECEIVE EXPIRED Nack Message was read successfully.")},
	{ MQMSG_CLASS_NACK_REACH_QUEUE_TIMEOUT, TEXT("The TIME TO REACH QUEUE EXPIRED Nack Message was read successfully.")},
	{ MQMSG_CLASS_NACK_Q_EXCEED_QUOTA, TEXT("The QUEUE IS FULL Nack Message was read successfully.")},
	{ MQMSG_CLASS_NACK_ACCESS_DENIED, TEXT("The SENDER HAVE NO SEND ACCESS RIGHTS ON QUEUE Nack Message was read successfully.")},
	{ MQMSG_CLASS_NACK_HOP_COUNT_EXCEEDED, TEXT("The HOP COUNT EXCEEDED Nack Message was read successfully.")},
	{ MQMSG_CLASS_NACK_BAD_SIGNATURE, TEXT("The MESSAGE RECEIVED WITH BAD SIGNATURE Nack Message was read successfully.")},
	{ MQMSG_CLASS_NACK_BAD_ENCRYPTION, TEXT("The MSG COULD NOT DECRYPTED Nack Message was read successfully.")},
    { MQMSG_CLASS_NACK_COULD_NOT_ENCRYPT, TEXT("The SOURCE QM COULD NOT ENCRYPT MSG FOR DEST QM Nack Message was read successfully.")},
	{ 0, NULL}
  };
	
void CMainFrame::ClassToString(unsigned short MsgClass,LPTSTR pszStatus)
{
	//
	// loop the StringClass array to find MsgClass
	//
	DWORD dwIndex = 0;
	while (StringClass[dwIndex].pszDescription != NULL)
	{
		if (StringClass[dwIndex].mclass == MsgClass)
		{
			_stprintf(pszStatus,StringClass[dwIndex].pszDescription);
			return;
		}
		dwIndex++;
	}

	//
	// MsgClass not found - print default error
	//
	_stprintf(pszStatus,TEXT("The NACK (0x%X) Message was read successfully."),MsgClass);
}


/* ************************************************************************ */
/*                            OnApiCreateQueue                              */
/* ************************************************************************ */
/* This function opens a dialog box and asks the user for the queue's       */
/* PathName and Label. Then it creates the specified queue.                 */
/*                                                                          */
/* Uses: MQCreateQueue.                                                     */
/* ************************************************************************ */
void CMainFrame::OnApiCreateQueue()
{
    // TODO: Add your command handler code here

    TCHAR szMsgBuffer[BUFFERSIZE];

    MQQUEUEPROPS QueueProps;
    MQPROPVARIANT aVariant[MAXINDEX];
    QUEUEPROPID aPropId[MAXINDEX];
    DWORD PropIdCount = 0;
    HRESULT hr;

    PSECURITY_DESCRIPTOR pSecurityDescriptor;

    TCHAR szPathNameBuffer[MAX_Q_PATHNAME_LEN];
    TCHAR szFormatNameBuffer[MAX_Q_FORMATNAME_LEN];
    TCHAR szLabelBuffer[MAX_Q_PATHNAME_LEN];
    DWORD dwFormatNameBufferLength = MAX_Q_FORMATNAME_LEN;


    //
    // Display CreateQueue Dialog.
    //
    CCreateQueueDialog CreateQueueDialog;

    if(CreateQueueDialog.DoModal() == IDCANCEL)
    {
        return;
    }
    CreateQueueDialog.GetPathName(szPathNameBuffer);
    CreateQueueDialog.GetLabel(szLabelBuffer);

    //
    // Get the input fields from the dialog box
    // and prepare the property array PROPVARIANT
    //


    //
    // Set the PROPID_Q_PATHNAME property
    //
    aPropId[PropIdCount] = PROPID_Q_PATHNAME;    //PropId
    aVariant[PropIdCount].vt = VT_LPWSTR;        //Type
    aVariant[PropIdCount].pwszVal = new WCHAR[MAX_Q_PATHNAME_LEN];
    _mqscpy(aVariant[PropIdCount].pwszVal, szPathNameBuffer); //Value

    PropIdCount++;

    //
    // Set the PROPID_Q_LABEL property
    //
    aPropId[PropIdCount] = PROPID_Q_LABEL;    //PropId
    aVariant[PropIdCount].vt = VT_LPWSTR;     //Type
    aVariant[PropIdCount].pwszVal = new WCHAR[MAX_Q_PATHNAME_LEN];
    _mqscpy(aVariant[PropIdCount].pwszVal, szLabelBuffer); //Value

    PropIdCount++;


    //
    // Set the MQEUEUPROPS structure
    //
    QueueProps.cProp = PropIdCount;           //No of properties
    QueueProps.aPropID = aPropId;             //Id of properties
    QueueProps.aPropVar = aVariant;           //Value of properties
    QueueProps.aStatus = NULL;                //No error reports

    //
    // No security (default)
    //
    pSecurityDescriptor = NULL;

    //
    // Create the queue
    //
#ifdef UNICODE
    hr = MQCreateQueue(
            pSecurityDescriptor,            //Security
            &QueueProps,                    //Queue properties
            szFormatNameBuffer,             //Output: Format Name
            &dwFormatNameBufferLength       //Output: Format Name len
            );
#else
    WCHAR szwFormatNameBuffer[MAX_Q_FORMATNAME_LEN];
    hr = MQCreateQueue(
            pSecurityDescriptor,            //Security
            &QueueProps,                    //Queue properties
            szwFormatNameBuffer,            //Output: Format Name
            &dwFormatNameBufferLength       //Output: Format Name len
            );

    if (SUCCEEDED(hr))
    {
        size_t rc =wcstombs(szFormatNameBuffer, szwFormatNameBuffer, dwFormatNameBufferLength);
        ASSERT(rc != (size_t)(-1));
    }
#endif

    if (FAILED(hr))
    {
        //
        // Error - display message
        //
        _stprintf(szMsgBuffer, TEXT("MQCreateQueue failed, Error code = 0x%x."),hr);
        MessageBox(szMsgBuffer, TEXT("ERROR"), MB_OK);
    }
    else
    {
        //
        // Success - write in edit control.
        //
        _stprintf(szMsgBuffer, TEXT("The queue %s was created successfully. ( FormatName: %s )"),
            szPathNameBuffer, szFormatNameBuffer);
        PrintToScreen(szMsgBuffer);

        //
        // Add the new queue to the PathName Array.
        //
        ARRAYQ* pNewQueue = new ARRAYQ;
        //
        // Save PathName and FormatName in the ARRAYQ structure.
        //
        _tcsncpy (pNewQueue->szPathName, szPathNameBuffer, MAX_Q_PATHNAME_LEN);
        _tcsncpy (pNewQueue->szFormatName, szFormatNameBuffer, MAX_Q_FORMATNAME_LEN);
        Add2PathNameArray(pNewQueue);
    }

    //
    // Free allocated memory
    //
    delete   aVariant[0].pwszVal;
    delete   aVariant[1].pwszVal;
}

/* ************************************************************************ */
/*                            OnApiDeleteQueue                              */
/* ************************************************************************ */
/* This function opens a dialog box and asks the user for the queue's       */
/* PathName. then it deletes the specified queue.                           */
/*                                                                          */
/* Uses: MQDeleteQueue.                                                     */
/* ************************************************************************ */
void CMainFrame::OnApiDeleteQueue()
{
    // TODO: Add your command handler code here
    TCHAR szPathNameBuffer[MAX_Q_PATHNAME_LEN];
    TCHAR szFormatNameBuffer[MAX_Q_PATHNAME_LEN];
    TCHAR szMsgBuffer[BUFFERSIZE];

    HRESULT hr;

    DWORD dwFormatNameBufferLength = MAX_Q_PATHNAME_LEN;

    CDeleteQueueDialog DeleteQueueDialog(&m_PathNameArray);

    //
    // Display DeleteQueue Dialog.
    //
    if (DeleteQueueDialog.DoModal() == IDCANCEL)
    {
        return;
    }

    DeleteQueueDialog.GetPathName(szPathNameBuffer);

    //
    // Translate the path name to format name using the ARRAYQ arrays.
    //
    if (TranslatePathNameToFormatName(szPathNameBuffer, szFormatNameBuffer) == FALSE)
    {
        //
        // Error - display message
        //
        _stprintf(szMsgBuffer, TEXT("Queue wasn't found"));
        MessageBox(szMsgBuffer, TEXT("ERROR"), MB_OK);
        return;
    }

    //
    // Delete the queue.
    //
#ifdef UNICODE
    hr = MQDeleteQueue(szFormatNameBuffer);  // FormatName of the Queue to be deleted.
#else
    WCHAR szwFormatNameBuffer[MAX_Q_FORMATNAME_LEN];
    size_t rc = mbstowcs(szwFormatNameBuffer, szFormatNameBuffer, _tcslen(szFormatNameBuffer)+1);
    ASSERT(rc != (size_t)(-1));
    hr = MQDeleteQueue(szwFormatNameBuffer);  // FormatName of the Queue to be deleted.
#endif

    if (FAILED(hr))
    {
        //
        // Error - display message
        //
        _stprintf(szMsgBuffer, TEXT("MQDeleteQueue failed, Error code = 0x%x."),hr);
        MessageBox(szMsgBuffer, TEXT("ERROR"), MB_OK);
    }
    else
    {
        //
        // Success - write in edit control
        //
        _stprintf(szMsgBuffer, TEXT("The queue %s was deleted successfully."), szPathNameBuffer);
        PrintToScreen(szMsgBuffer);
        //
        // Delete the name from the Path Names array.
        //
        ARRAYQ* DeletedQueue = RemoveFromPathNameArray(szPathNameBuffer);
        if (DeletedQueue != NULL)
        {
            delete DeletedQueue;
        }
    }
}

/* ************************************************************************ */
/*                             OnApiOpenQueue                               */
/* ************************************************************************ */
/* This function opens a dialog box and asks the user for the queue's       */
/* PathName. then it opens the specified queue.                             */
/*                                                                          */
/* Uses: MQOpenQueue.                                                       */
/* ************************************************************************ */
void CMainFrame::OnApiOpenQueue()
{
    // TODO: Add your command handler code here
    TCHAR szPathNameBuffer[MAX_Q_PATHNAME_LEN];
    TCHAR szFormatNameBuffer[MAX_Q_PATHNAME_LEN];
    TCHAR szAccessBuffer[ACCESSBUFFERSIZE]; 
    TCHAR szMsgBuffer[BUFFERSIZE];

    HRESULT hr;

    DWORD dwFormatNameBufferLength = MAX_Q_PATHNAME_LEN;
    DWORD dwAccess;

    QUEUEHANDLE hQueue;

    COpenQueueDialog OpenQueueDialog(&m_PathNameArray);

    //
    // Display the OpenQueue dialog.
    //
    if (OpenQueueDialog.DoModal() == IDCANCEL)
    {
        return;
    }

    OpenQueueDialog.GetPathName(szPathNameBuffer);
    dwAccess = OpenQueueDialog.GetAccess();
    //
    // Set the access buffer string.
    //
    switch (dwAccess)
    {
    case (MQ_RECEIVE_ACCESS | MQ_SEND_ACCESS):

        _tcscpy(szAccessBuffer, TEXT("MQ_RECEIVE_ACCESS, MQ_SEND_ACCESS."));
        break;

    case MQ_RECEIVE_ACCESS:

        _tcscpy(szAccessBuffer, TEXT("MQ_RECEIVE_ACCESS."));
        break;

    case MQ_SEND_ACCESS:

        _tcscpy(szAccessBuffer, TEXT("MQ_SEND_ACCESS."));
        break;

    default:

        _tcscpy(szAccessBuffer, TEXT("NONE."));
        break;
    }

    //
    // Translate the path name to format name using the ARRAYQ arrays.
    //
    if (TranslatePathNameToFormatName(szPathNameBuffer, szFormatNameBuffer) == FALSE)
    {
        //
        // Error - display message
        //
        _stprintf(szMsgBuffer, TEXT("Queue wasn't found"));
        MessageBox(szMsgBuffer, TEXT("ERROR"), MB_OK);
        return;
    }

    //
    // Open the queue. (no sharing)
    //
#ifdef UNICODE
    hr = MQOpenQueue(
            szFormatNameBuffer,     // Format Name of the queue to be opened.
            dwAccess,               // Access rights to the Queue.
            0,                      // No receive Exclusive.
            &hQueue                 // OUT: handle to the opened Queue.
            );
#else
    WCHAR szwFormatNameBuffer[MAX_Q_FORMATNAME_LEN];
    size_t rc = mbstowcs(szwFormatNameBuffer, szFormatNameBuffer, _tcslen(szFormatNameBuffer)+1);
    ASSERT(rc != (size_t)(-1));

    hr = MQOpenQueue(
            szwFormatNameBuffer,    // Format Name of the queue to be opened.
            dwAccess,               // Access rights to the Queue.
            0,                      // No receive Exclusive.
            &hQueue                 // OUT: handle to the opened Queue.
            );
#endif

    if (FAILED(hr))
    {
        //
        // Error - display message
        //
        _stprintf(szMsgBuffer, TEXT("MQOpenQueue failed, Error code = 0x%x."),hr);
        MessageBox(szMsgBuffer, TEXT("ERROR"), MB_OK);
    }
    else
    {
        //
        // Success - write in edit control
        //
        _stprintf(szMsgBuffer,
            TEXT("The queue %s was opened successfully.\r\n\tQueueHandle: 0x%x\r\n\tQueue Access : %s"),
            szPathNameBuffer,
            hQueue,
            szAccessBuffer);
        PrintToScreen(szMsgBuffer);

        //
        // move the queue to the opened queues array.
        //
        MoveToOpenedQueuePathNameArray(szPathNameBuffer, hQueue, dwAccess);
    }
}

/* ************************************************************************ */
/*                            OnApiCloseQueue                               */
/* ************************************************************************ */
/* This function opens a dialog box and asks the user for the queue's       */
/* PathName. then it closes the specified queue.                            */
/*                                                                          */
/* Uses: MQCloseQueue.                                                      */
/* ************************************************************************ */
void CMainFrame::OnApiCloseQueue()
{
    // TODO: Add your command handler code here

    TCHAR szPathNameBuffer[MAX_Q_PATHNAME_LEN];
    TCHAR szMsgBuffer[BUFFERSIZE];

    HRESULT hr;

    DWORD dwFormatNameBufferLength = MAX_Q_PATHNAME_LEN;

    QUEUEHANDLE hClosedQueueHandle;

    //
    // Display CloseQueue Dialog.
    //
    CCloseQueueDialog CloseQueueDialog(&m_OpenedQueuePathNameArray);

    if (CloseQueueDialog.DoModal() == IDCANCEL)
    {
        return;
    }

    CloseQueueDialog.GetPathName(szPathNameBuffer);

    //
    // Get the closed queue handle.
    //
    if (GetQueueHandle(szPathNameBuffer, &hClosedQueueHandle) == FALSE)
    {
        //
        // Error - display message
        //
        _stprintf(szMsgBuffer, TEXT("The Queue couldn't be closed since it was not opened before."));
        MessageBox(szMsgBuffer, TEXT("ERROR"), MB_OK);
        return;
    }

    //
    // Close the queue.
    //
    hr = MQCloseQueue(hClosedQueueHandle);   // the handle of the Queue to be closed.
    if (FAILED(hr))
    {
        //
        // Error - display message
        //
        _stprintf(szMsgBuffer, TEXT("MQCloseQueue failed, Error code = 0x%x."),hr);
        MessageBox(szMsgBuffer, TEXT("ERROR"), MB_OK);
    }
    else
    {
        //
        // Success - write in edit control
        //
        _stprintf(szMsgBuffer, TEXT("The queue %s was closed successfully."), szPathNameBuffer);
        PrintToScreen(szMsgBuffer);
        //
        // Move the queue form the opened queues array to the path name array.
        //
        MoveToPathNameArray(szPathNameBuffer);
    }
}

/* ************************************************************************ */
/*                            OnApiSendMessage                              */
/* ************************************************************************ */
/* This function opens a dialog box and asks the user for the queue's       */
/* PathName and some message properties. Then it sends the message to the   */
/* specified queue.                                                         */
/*                                                                          */
/* Uses: MQSendMessage.                                                     */
/* ************************************************************************ */

//
// two static buffers to hold the last message body and label for the next time.
//
TCHAR szLastMessageBody[BUFFERSIZE];
TCHAR szLastMessageLabel[BUFFERSIZE];

void CMainFrame::OnApiSendMessage()
{
    // TODO: Add your command handler code here

    TCHAR szPathNameBuffer[MAX_Q_PATHNAME_LEN];
    TCHAR szAdminPathNameBuffer[MAX_Q_PATHNAME_LEN];
    TCHAR szAdminFormatNameBuffer[MAX_Q_FORMATNAME_LEN];
    TCHAR szMsgBuffer[BUFFERSIZE];

    MQMSGPROPS MsgProps;
    MQPROPVARIANT aVariant[MAXINDEX];
    MSGPROPID aPropId[MAXINDEX];
    DWORD PropIdCount = 0;

    HRESULT hr;

    unsigned char bPriority;
    unsigned char bDelivery;
    unsigned char bJournal;
    unsigned char bDeadLetter;
	unsigned char bAuthenticated;
	unsigned char bEncrypted;
    unsigned char bAcknowledge;

    WCHAR szMessageBodyBuffer [BUFFERSIZE];
    WCHAR szMessageLabelBuffer[BUFFERSIZE];
    DWORD dwTimeToReachQueue;
	DWORD dwTimeToBeReceived;

    QUEUEHANDLE hQueue;

    CSendMessageDialog SendMessageDialog(&m_OpenedQueuePathNameArray);

    //
    // Display the SendMessage dialog.
    //
    if (SendMessageDialog.DoModal() == IDCANCEL)
    {
        return;
    }

    //
    // Retrieve the properties from the dialog box.
    //
    SendMessageDialog.GetPathName(szPathNameBuffer);
    SendMessageDialog.GetAdminPathName(szAdminPathNameBuffer);
    bPriority = SendMessageDialog.GetPriority();
    bDelivery = SendMessageDialog.GetDelivery();
    bJournal = SendMessageDialog.GetJournal();
    bDeadLetter = SendMessageDialog.GetDeadLetter();
	bAuthenticated = SendMessageDialog.GetAuthenticated();
	bEncrypted = SendMessageDialog.GetEncrypted();
    bAcknowledge = SendMessageDialog.GetAcknowledge();
    SendMessageDialog.GetMessageBody(szLastMessageBody);
    SendMessageDialog.GetMessageLabel(szLastMessageLabel);
    dwTimeToReachQueue = SendMessageDialog.GetTimeToReachQueue();
	dwTimeToBeReceived = SendMessageDialog.GetTimeToBeReceived();

    //
    // Update the Last message properties.
    //
    _mqscpy(szMessageBodyBuffer, szLastMessageBody);
    _mqscpy(szMessageLabelBuffer, szLastMessageLabel);

    //
    // Get the target queue handle.
    //
    if (GetQueueHandle(szPathNameBuffer, &hQueue) == FALSE)
    {
        //
        // Error - display message
        //
        _stprintf(szMsgBuffer, TEXT("GetQueueHandle failed. Queue not opened yet."));
        MessageBox(szMsgBuffer, TEXT("ERROR"), MB_OK);
        return;
    }

    //
    // Get the admin queue FormatName.
    //
    if (TranslateOpenedQueuePathNameToFormatName(szAdminPathNameBuffer, szAdminFormatNameBuffer) == FALSE)
    {
        //
        // Error - display message
        //
        _stprintf(szMsgBuffer, TEXT("TranslatePathNameToFormatName failed, Queue has not been opened yet."));
        MessageBox(szMsgBuffer, TEXT("ERROR"), MB_OK);
        return;
    }

    //
    // prepare the property array PROPVARIANT.
    //

    //
    // Set the PROPID_M_PRIORITY property.
    //
    aPropId[PropIdCount] = PROPID_M_PRIORITY;    //PropId
    aVariant[PropIdCount].vt = VT_UI1;           //Type
    aVariant[PropIdCount].bVal = bPriority;      //Value

    PropIdCount++;

    //
    // Set the PROPID_M_DELIVERY property.
    //
    aPropId[PropIdCount] = PROPID_M_DELIVERY;    //PropId
    aVariant[PropIdCount].vt = VT_UI1;           //Type
    aVariant[PropIdCount].bVal = bDelivery;      //Value

    PropIdCount++;

    //
    // Set the PROPID_M_ACKNOWLEDGE property.
    //
    aPropId[PropIdCount] = PROPID_M_ACKNOWLEDGE; //PropId
    aVariant[PropIdCount].vt = VT_UI1;           //Type
    aVariant[PropIdCount].bVal = bAcknowledge;   //Value

    PropIdCount++;

    //
    // Set the PROPID_M_BODY property.
    //
    aPropId[PropIdCount] = PROPID_M_BODY;                  //PropId
    aVariant[PropIdCount].vt = VT_VECTOR|VT_UI1;           //Type
    aVariant[PropIdCount].caub.cElems =
        (wcslen(szMessageBodyBuffer) + 1) * sizeof(WCHAR); //Value
    aVariant[PropIdCount].caub.pElems = (unsigned char *)szMessageBodyBuffer;

    PropIdCount++;

    //
    // Set the PROPID_M_LABEL property.
    //
    aPropId[PropIdCount] = PROPID_M_LABEL;                  //PropId
    aVariant[PropIdCount].vt = VT_LPWSTR;                   //Type
    aVariant[PropIdCount].pwszVal = szMessageLabelBuffer;     //Value

    PropIdCount++;

    //
    // Set the PROPID_M_TIME_TO_REACH_QUEUE property.
    //
    aPropId[PropIdCount] = PROPID_M_TIME_TO_REACH_QUEUE;    //PropId
    aVariant[PropIdCount].vt = VT_UI4;                      //Type
    aVariant[PropIdCount].ulVal = dwTimeToReachQueue;       //Value

    PropIdCount++;

    //
    // Set the PROPID_M_TIME_TO_BE_RECEIVED property.
    //
    aPropId[PropIdCount] = PROPID_M_TIME_TO_BE_RECEIVED;    //PropId
    aVariant[PropIdCount].vt = VT_UI4;                      //Type
    aVariant[PropIdCount].ulVal = dwTimeToBeReceived;       //Value

    PropIdCount++;


    if (bJournal || bDeadLetter)
    {
        //
        // Set the PROPID_M_JOURNAL property.
        //
        aPropId[PropIdCount] = PROPID_M_JOURNAL;            //PropId
        aVariant[PropIdCount].vt = VT_UI1;                  //Type

        if (bJournal)
            aVariant[PropIdCount].bVal = MQMSG_JOURNAL;
        else
            aVariant[PropIdCount].bVal = 0;
        if (bDeadLetter)
            aVariant[PropIdCount].bVal |= MQMSG_DEADLETTER;

        PropIdCount++;
    }


	if (bAuthenticated)
	{
		//
		// Set the PROPID_M_AUTH_LEVEL property.
		//
		aPropId[PropIdCount] = PROPID_M_AUTH_LEVEL;            //PropId
		aVariant[PropIdCount].vt = VT_UI4;                     //Type
		aVariant[PropIdCount].ulVal = MQMSG_AUTH_LEVEL_ALWAYS; //Value

		PropIdCount++;
	}

	if (bEncrypted)
	{
		//
		// Set the PROPID_M_ENCRYPTION_ALG property.
		//
		aPropId[PropIdCount] = PROPID_M_PRIV_LEVEL;            //PropId
		aVariant[PropIdCount].vt = VT_UI4;                     //Type
		aVariant[PropIdCount].ulVal = MQMSG_PRIV_LEVEL_BODY;   //Value

		PropIdCount++;
	}


    //
    // Set the PROPID_M_ADMIN_QUEUE property.
    //
    aPropId[PropIdCount] = PROPID_M_ADMIN_QUEUE;               //PropId
    aVariant[PropIdCount].vt = VT_LPWSTR;                      //Type
#ifdef UNICODE
    aVariant[PropIdCount].pwszVal = szAdminFormatNameBuffer;   //Value
#else
    WCHAR szwAdminFormatNameBuffer[MAX_Q_FORMATNAME_LEN];
    size_t rc = mbstowcs(szwAdminFormatNameBuffer,
                    szAdminFormatNameBuffer,
                    _tcslen(szAdminFormatNameBuffer)+1);
    ASSERT(rc != (size_t)(-1));
    aVariant[PropIdCount].pwszVal = szwAdminFormatNameBuffer;  //Value
#endif

    PropIdCount++;

    //
    // Set the MQMSGPROPS structure
    //
    MsgProps.cProp = PropIdCount;       //Number of properties.
    MsgProps.aPropID = aPropId;         //Id of properties.
    MsgProps.aPropVar = aVariant;       //Value of properties.
    MsgProps.aStatus  = NULL;           //No Error report.

    //
    // Send the message.
    //
    hr = MQSendMessage(
            hQueue,                     // handle to the Queue.
            &MsgProps,                  // Message properties to be sent.
            NULL                        // No transaction
            );

    if (FAILED(hr))
    {
        //
        // Error - display message
        //
        _stprintf(szMsgBuffer, TEXT("MQSendMessage failed, Error code = 0x%x."),hr);
        MessageBox(szMsgBuffer, TEXT("ERROR"), MB_OK);
    }
    else
    {
        //
        // Success - write in edit control
        //
        _stprintf(szMsgBuffer, TEXT("The Message \"%s\" was sent successfully."), szLastMessageLabel);
        PrintToScreen(szMsgBuffer);
    }
}

/* ************************************************************************ */
/*                           OnApiReceiveMessage                            */
/* ************************************************************************ */
/* This function opens a dialog box and asks the user for the queue's       */
/* PathName and the Time to wait for the message. Then it tries to get a    */
/* message from the specified queue at the given time.                      */
/*                                                                          */
/* Uses: MQReceiveMessage, MQFreeMemory.                                    */
/* ************************************************************************ */
void CMainFrame::OnApiReceiveMessage()
{
    TCHAR szPathNameBuffer[MAX_Q_PATHNAME_LEN];
    TCHAR szMsgBuffer[2*BUFFERSIZE];
    TCHAR szDomainName[BUFFERSIZE];
	 TCHAR szAccountName[BUFFERSIZE];
    DWORD dwActNameSize = sizeof(szAccountName);
    DWORD dwDomNameSize = sizeof(szDomainName);
    TCHAR szTextSid[BUFFERSIZE];
    DWORD dwTextSidSize = sizeof(szTextSid);
    BYTE  blobBuffer[BUFFERSIZE];

    MQMSGPROPS MsgProps;
    MQPROPVARIANT aVariant[MAXINDEX];
    MSGPROPID aPropId[MAXINDEX];
    DWORD PropIdCount = 0;

    HRESULT hr;

    WCHAR szMessageLabelBuffer[BUFFERSIZE];
    DWORD dwTimeout;

    QUEUEHANDLE hQueue;

    CReceiveWaitDialog    WaitDialog;
    CReceiveMessageDialog ReceiveMessageDialog(&m_OpenedQueuePathNameArray);

    //
    // Display the ReceiveMessage dialog.
    //
    if (ReceiveMessageDialog.DoModal() == IDCANCEL)
    {
        return;
    }

    ReceiveMessageDialog.DestroyWindow();
    ReceiveMessageDialog.GetPathName(szPathNameBuffer);

    //
    // Get the queue handle.
    //
    if (GetQueueHandle(szPathNameBuffer, &hQueue) == FALSE)
    {
        //
        // Error - display message
        //
        _stprintf(szMsgBuffer, TEXT("GetQueueHandle failed. Queue was not found in Opened Queue Array"));
        MessageBox(szMsgBuffer, TEXT("ERROR"), MB_OK);
        return;
    }

    //
    // Retrieve the properties form the dialog box.
    //
    dwTimeout = ReceiveMessageDialog.GetTimeout();


    //
    // prepare the property array PROPVARIANT of
    // message properties that we want to receive
    //

    //
    // Set the PROPID_M_BODY property.
    //
    aPropId[PropIdCount] = PROPID_M_BODY;                                //PropId
    aVariant[PropIdCount].vt = VT_VECTOR|VT_UI1;                         //Type
    aVariant[PropIdCount].caub.cElems = ReceiveMessageDialog.GetBodySize() ;
    aVariant[PropIdCount].caub.pElems = (unsigned char *) new
                               char [ aVariant[PropIdCount].caub.cElems ] ;

    int iBodyIndex = PropIdCount ;
    PropIdCount++;

    //
    // Set the PROPID_M_LABEL property.
    //
    aPropId[PropIdCount] = PROPID_M_LABEL;                   //PropId
    aVariant[PropIdCount].vt = VT_LPWSTR;                    //Type
    aVariant[PropIdCount].pwszVal = szMessageLabelBuffer;

    PropIdCount++;

    //
    // Set the PROPID_M_PRIORITY property.
    //
    aPropId[PropIdCount] = PROPID_M_PRIORITY;               //PropId
    aVariant[PropIdCount].vt = VT_UI1;                      //Type

    PropIdCount++;

    //
    // Set the PROPID_M_CLASS property.
    //
    aPropId[PropIdCount] = PROPID_M_CLASS;                  //PropId
    aVariant[PropIdCount].vt = VT_UI2;                      //Type

    PropIdCount++;

    //
    // Set the PROPID_M_AUTHENTICATED property.
    //
    aPropId[PropIdCount] = PROPID_M_AUTHENTICATED;          //PropId
    aVariant[PropIdCount].vt = VT_UI1;                      //Type

    PropIdCount++;

	//
	// Set the PROPID_M_SENDERID property
	//
	aPropId[PropIdCount] = PROPID_M_SENDERID;               //PropId
	aVariant[PropIdCount].vt = VT_UI1|VT_VECTOR;            //Type
	aVariant[PropIdCount].blob.pBlobData = blobBuffer;
	aVariant[PropIdCount].blob.cbSize = sizeof(blobBuffer);

	PropIdCount++;

	//
	// Set the PROPID_M_PRIV_LEVEL property
	//
	aPropId[PropIdCount] = PROPID_M_PRIV_LEVEL;             //PropId
	aVariant[PropIdCount].vt = VT_UI4          ;            //Type

	PropIdCount++;

    //
    // Set the PROPID_M_LABEL_LEN property.
    //
    aPropId[PropIdCount] = PROPID_M_LABEL_LEN;              //PropId
    aVariant[PropIdCount].vt = VT_UI4;                      //Type
    aVariant[PropIdCount].ulVal = BUFFERSIZE;               //Value

    PropIdCount++;


    //
    // Set the MQMSGPROPS structure
    //
    MsgProps.cProp = PropIdCount;       //Number of properties.
    MsgProps.aPropID = aPropId;         //Id of properties.
    MsgProps.aPropVar = aVariant;       //Value of properties.
    MsgProps.aStatus  = NULL;           //No Error report.

    //
    // Display a message window until the message from the queue will be received.
    //
    WaitDialog.Create(IDD_WAIT_DIALOG,pMainView);
    WaitDialog.ShowWindow(SW_SHOWNORMAL);
    WaitDialog.UpdateWindow();
    WaitDialog.CenterWindow();
    pMainView->RedrawWindow();

    //
    // Receive the message.
    //
    hr = MQReceiveMessage(
               hQueue,               // handle to the Queue.
               dwTimeout,            // Max time (msec) to wait for the message.
               MQ_ACTION_RECEIVE,    // Action.
               &MsgProps,            // properties to retrieve.
               NULL,                 // No overlaped structure.
               NULL,                 // No callback function.
               NULL,                 // No Cursor.
               NULL                  // No transaction
               );

    WaitDialog.ShowWindow(SW_HIDE);


	if(hr == MQ_ERROR_IO_TIMEOUT)
	{
        _stprintf(szMsgBuffer, TEXT("MQReceiveMessage failed, Timeout expired."),hr);
        MessageBox(szMsgBuffer, TEXT("ERROR"), MB_OK);
	}
	else if(hr != MQ_OK)
	{
        //
        // Error - display message
        //
        _stprintf(szMsgBuffer, TEXT("MQReceiveMessage failed, Error code = 0x%x."),hr);
        MessageBox(szMsgBuffer, TEXT("ERROR"), MB_OK);
	}
	else
	{
        //
        // Success - write in edit control
        //
		ClassToString(aVariant[3].uiVal,szMsgBuffer);
        PrintToScreen(szMsgBuffer);

        //
        // Print some of the Message properties.
        //
#ifdef UNICODE
        _stprintf(szMsgBuffer, TEXT("\tLabel: %s"), (WCHAR *)(aVariant[1].pwszVal));
#else
        {
            PCHAR lpLable = UnicodeStringToAnsiString((WCHAR *)(aVariant[1].pwszVal));
            _stprintf(szMsgBuffer, TEXT("\tLabel: %s"), lpLable);
            delete [] lpLable;
        }
#endif
        PrintToScreen(szMsgBuffer);

        //
        // Only if the message is not a falcon message print the body.
        // (this is done since in ACK messages there is no message body).
        //
        if (aVariant[3].bVal == MQMSG_CLASS_NORMAL)
        {
#ifdef UNICODE
            _stprintf(szMsgBuffer, TEXT("\tBody : %s"), (WCHAR *)(aVariant[0].caub.pElems));
#else
            {
                PCHAR pBody = UnicodeStringToAnsiString((WCHAR *)(aVariant[0].caub.pElems));
                _stprintf(szMsgBuffer, TEXT("\tBody : %s"), pBody);
                delete [] pBody;
            }
#endif
            PrintToScreen(szMsgBuffer);
        }

        _stprintf(szMsgBuffer, TEXT("\tPriority : %d"), aVariant[2].bVal);
        PrintToScreen(szMsgBuffer);


		//
		// Print Sender ID
		//
        //
        // See if we're running on NT or Win95.
        //
        OSVERSIONINFO OsVerInfo;

        OsVerInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
        GetVersionEx(&OsVerInfo);

        if (OsVerInfo.dwPlatformId == VER_PLATFORM_WIN32_NT)
        {
            //
            //  On NT
            //
		    SID_NAME_USE peUse;
		    if (LookupAccountSid(NULL,
							     blobBuffer,
							     szAccountName,
							     &dwActNameSize,
							     szDomainName,
							     &dwDomNameSize,
							     &peUse) )
            {
                _stprintf(szMsgBuffer, TEXT("\tUser: %s\\%s"),
			        (WCHAR *)(szDomainName),(WCHAR *)(szAccountName));
		        PrintToScreen(szMsgBuffer);
            }
        }
        else
        {
            //
            // LookupAccountSid is not implemented on Win95,
            // instead print textual sid
            //
            if ( GetTextualSid((PSID)blobBuffer, szTextSid, &dwTextSidSize))
            {
                _stprintf(szMsgBuffer, TEXT("\tUser SID : %s"), szTextSid);
		        PrintToScreen(szMsgBuffer);
            }
        }
		//
		// Print "Authenticated" or "Non Authenticated"
		//
		if (aVariant[4].bVal)
			PrintToScreen(TEXT("\tMessage is Authenticated."));
		else
			PrintToScreen(TEXT("\tMessage is Not Authenticated."));


		//
		// Print "Encrypted" or "Non Encrypted"
		//
		if (aVariant[6].ulVal)
			PrintToScreen(TEXT("\tMessage is Encrypted."));
		else
			PrintToScreen(TEXT("\tMessage is Not Encrypted."));
   }

   delete aVariant[ iBodyIndex ].caub.pElems ;
}

/* ************************************************************************ */
/*                               OnApiLocate                                */
/* ************************************************************************ */
/* This function opens a dialog box and ask the user to give a Label. Then  */
/* it locates all the Queues in the DS with a matching label.               */
/* The function updates the PathName Array with those queues.               */
/*                                                                          */
/* Uses: MQLocateBegin, MQLocateNext, MQLocateEnd,                          */
/*       MQInstanceToFormatName, MQFreeMemory.                              */
/* ************************************************************************ */
void CMainFrame::OnApiLocate()
{
    // TODO: Add your command handler code here
    TCHAR szMsgBuffer[BUFFERSIZE];
    TCHAR szLabelBuffer[BUFFERSIZE];

    HRESULT hr;

    MQPROPERTYRESTRICTION PropertyRestriction;
    MQRESTRICTION  Restriction;
    MQCOLUMNSET    Column;
    QUEUEPROPID    aPropId[2]; // only two properties to retrieve.
    HANDLE         hEnum;
    DWORD       cQueue;
    MQPROPVARIANT   aPropVar[MAX_VAR] = {0};
    ARRAYQ*         pArrayQ;
    DWORD       i;
    DWORD           dwColumnCount = 0;
    DWORD dwFormatNameLength = MAX_Q_FORMATNAME_LEN;

    CLocateDialog LocateDialog;

    //
    // Display the ReceiveMessage dialog.
    //
    if (LocateDialog.DoModal() == IDCANCEL)
    {
        return;
    }

    //
    // Retrieve the label from the dialog box.
    //
    LocateDialog.GetLabel(szLabelBuffer);

    //
    // Clean the PathNameArray before locate.
    //
    CleanPathNameArray();

    //
    // Prepare Parameters to locate a queue.
    //

    //
    // Prepare property restriction.
    // Restriction = All queue with PROPID_Q_LABEL equal to "MQ API test".
    //
    PropertyRestriction.rel = PREQ;
    PropertyRestriction.prop = PROPID_Q_LABEL;
    PropertyRestriction.prval.vt = VT_LPWSTR;
#ifdef UNICODE
    PropertyRestriction.prval.pwszVal = szLabelBuffer;
#else
    DWORD size = _tcslen(szLabelBuffer) +1;
    PropertyRestriction.prval.pwszVal = new WCHAR[size];
    AnsiStringToUnicode(PropertyRestriction.prval.pwszVal, szLabelBuffer,size);
#endif

    //
    // prepare a restriction with one property restriction.
    //
    Restriction.cRes = 1;
    Restriction.paPropRes = &PropertyRestriction;

    //
    // Columset (In other words what property I want to retrieve).
    // Only the PathName is important.
    //
    aPropId[dwColumnCount] = PROPID_Q_PATHNAME;
    dwColumnCount++;

    aPropId[dwColumnCount] = PROPID_Q_INSTANCE;
    dwColumnCount++;

    Column.cCol = dwColumnCount;
    Column.aCol = aPropId;

    //
    // Locate the queues. Issue the query
    //
    hr = MQLocateBegin(
            NULL,           //start search at the top.
            &Restriction,   //Restriction
            &Column,        //ColumnSet
            NULL,           //No sort order
            &hEnum          //Enumeration Handle
            );

    if(FAILED(hr))
    {
        //
        // Error - display message
        //
        _stprintf(szMsgBuffer,
            TEXT("MQLocateBegin failed, Error code = 0x%x."),hr);
        MessageBox(szMsgBuffer, TEXT("ERROR"), MB_OK);
        return;
    }

    //
    // Get the results.
    //
    cQueue = MAX_VAR;

    //
    // If cQueue == 0 it means that no Variants were retrieved in the last MQLocateNext.
    //
    while (cQueue != 0)
    {
        hr = MQLocateNext(
                hEnum,      // handle returned by MQLocateBegin.
                &cQueue,    // size of aPropVar array.
                aPropVar    // OUT: an array of MQPROPVARIANT to get the results in.
                );

        if(FAILED(hr))
        {
            //
            // Error - display message
            //
            _stprintf(szMsgBuffer,
                TEXT("MQLocateNext failed, Error code = 0x%x."),hr);
            MessageBox(szMsgBuffer, TEXT("ERROR"), MB_OK);
            return;
        }

        for (i=0; i<cQueue; i++)
        {
            //
            // add the new path names to the path name array.
            //
            pArrayQ = new ARRAYQ;
#ifdef UNICODE
            wcsncpy (pArrayQ->szPathName, aPropVar[i].pwszVal, MAX_Q_PATHNAME_LEN);
#else
            size_t rc = wcstombs(pArrayQ->szPathName, aPropVar[i].pwszVal, MAX_Q_PATHNAME_LEN);
            ASSERT(rc != (size_t)(-1));
#endif
            //
            // move to the next property.
            //
            i = i + 1;

            //
            // Get the FormatName of the queue and set it in the PathName array.
            //
#ifdef UNICODE
            hr = MQInstanceToFormatName(aPropVar[i].puuid, pArrayQ->szFormatName, &dwFormatNameLength);
#else
            WCHAR szwFormatNameBuffer[MAX_Q_FORMATNAME_LEN];
            hr = MQInstanceToFormatName(aPropVar[i].puuid, szwFormatNameBuffer, &dwFormatNameLength);
            if (SUCCEEDED(hr))
            {
                size_t rwc =wcstombs(pArrayQ->szFormatName, szwFormatNameBuffer, dwFormatNameLength);
                ASSERT(rwc != (size_t)(-1));
            }
#endif

            if(FAILED(hr))
            {
                //
                // Error - display message
                //
                _stprintf (szMsgBuffer,
                    TEXT("MQInstanceToFormatName failed, Error code = 0x%x."),hr);
                MessageBox(szMsgBuffer, TEXT("ERROR"), MB_OK);
            }

            //
            // Free the memory allocated by MSMQ
            //
            MQFreeMemory(aPropVar[i].pwszVal);

            //
            // Add the new Queue to the PathNameArray.
            //
            Add2PathNameArray(pArrayQ);
        }
    }

    //
    // End the locate operation.
    //
    hr = MQLocateEnd(hEnum);   // handle returned by MQLocateBegin.
    if(FAILED(hr))
    {
        //
        // Error - display message
        //
        _stprintf (szMsgBuffer,
            TEXT("MQLocateEnd failed, Error code = 0x%x."),hr);
        MessageBox(szMsgBuffer, TEXT("ERROR"), MB_OK);
        return;
    }

    //
    // Display the Queues found on the locate.
    //
    _stprintf (szMsgBuffer, TEXT("Locate Operation completed successfully"));
    PrintToScreen(szMsgBuffer);
    UpdatePathNameArrays();
    DisplayPathNameArray();
    DisplayOpenedQueuePathNameArray();
}

/* ************************************************************************ */
/*                           OnUpdateFrameTitle                             */
/* ************************************************************************ */
void CMainFrame::OnUpdateFrameTitle(BOOL bAddToTitle)
{
    SetWindowText (TEXT("MQ API test"));
}