예제 #1
1
bool CMsmqWarpper::OpenPublicQueue(LPCWSTR wszPathName, bool connecttype)
{
	if (wszPathName == NULL)
	{
		return false;
	}

	HRESULT hr = MQ_OK;

	if (connecttype)
	{
		DWORD dwFormatNameBufferLength = 256; 
		WCHAR wszFormatNameBuffer[256] = {0};

		hr = MQPathNameToFormatName(wszPathName,
			wszFormatNameBuffer,
			&dwFormatNameBufferLength);
		if (FAILED(hr))
		{
			return false;
		}

		hr = MQOpenQueue(wszFormatNameBuffer, 
			MQ_SEND_ACCESS, 
			MQ_DENY_NONE, 
			&m_hQueue
			);
	}
	else
	{
		hr = MQOpenQueue(wszPathName, 
			MQ_SEND_ACCESS, 
			MQ_DENY_NONE, 
			&m_hQueue
			);
	}
	if (FAILED(hr))
	{
		return false;
	}

	return true;

}
//-----------------------------------------------------
//
// Sender in workgroup (direct) mode
//
//-----------------------------------------------------
void DirectSender(void)
{

    MQMSGPROPS    msgprops;
    MQPROPVARIANT aPropVar[MAX_VAR];
    MSGPROPID     amPropId[MAX_VAR];
    DWORD         cProps;

    WCHAR         wcsFormat[MAX_FORMAT];
    WCHAR         wcsReceiverComputer[MAX_COMPUTERNAME_LENGTH + 1];

    UCHAR         Buffer[MAX_BUFFER];
    WCHAR         wcsMsgLabel[MQ_MAX_MSG_LABEL_LEN+1];

    QUEUEHANDLE   qhSend;

    HRESULT       hr;
	int			  nPos;

    //
    // Get the receiver computer name.
    //
    printf("Enter receiver computer name: ");
	if (fgetws(wcsReceiverComputer, MAX_COMPUTERNAME_LENGTH, stdin) == NULL)
	{
        printf("An invalid parameter was entered. Exiting...\n");
        exit(1);
	}
	wcsReceiverComputer[MAX_COMPUTERNAME_LENGTH] = L'\0';
	//
	// Deleting the new-line character.
	//
	if(wcsReceiverComputer[wcslen(wcsReceiverComputer) - 1] == L'\n')
	{
		wcsReceiverComputer[wcslen(wcsReceiverComputer) - 1] = L'\0'; 
	}
    
    if(wcsReceiverComputer[0] == 0)
    {
        printf("An invalid parameter was entered. Exiting...\n");
        exit(1);
    }

    //
    // Open the queue with send access.
    //
	nPos = _snwprintf_s(
                   wcsFormat, 
                   sizeof(wcsFormat)/sizeof(wcsFormat[0]), 
                   sizeof(wcsFormat)/sizeof(wcsFormat[0]) - 1, 
                   L"DIRECT=OS:%s\\private$\\MSMQTest", 
                   wcsReceiverComputer
                   );
	if(nPos < 0)
	{
		printf("The format name is too long for the buffer. Exiting...\n");
		exit(1);
	}	

    hr = MQOpenQueue(
             wcsFormat,           // IN:  Queue format name
             MQ_SEND_ACCESS,      // IN:  Want to send to queue
             0,                   // IN:  Must be 0 for send access
             &qhSend);            // OUT: Handle of open queue

    if (FAILED(hr))
        Error("MQOpenQueue failed", hr);


    printf("\nEnter \"quit\" to exit\n");


    //
    // Construct the message label.
    //
	nPos = _snwprintf_s(
                   wcsMsgLabel, 
                   sizeof(wcsMsgLabel)/sizeof(wcsMsgLabel[0]), 
                   sizeof(wcsMsgLabel)/sizeof(wcsMsgLabel[0]) - 1, 
                   L"Message from %S", 
                   mbsMachineName);
	if(nPos < 0)
	{
		printf("The label is too long for the buffer. Exiting...\n");
		exit(1);
	}	
	
    
    fflush(stdin);

    //
    // Main sender loop
    //
    for(;;)
    {
        //
        // Get a string from the console.
        //
        printf("Enter a string: ");
        if (fgets(Buffer, MAX_BUFFER - 1, stdin) == NULL)
            break;

		Buffer[MAX_BUFFER-1] = '\0';
		//
		// Delete the new-line character.
		//
		if(Buffer[strlen(Buffer) - 1] == '\n')
		{
			Buffer[strlen(Buffer) - 1] = '\0'; 
		}

        //
        // Set the message properties for sending messages.
        //
        cProps = 0;

        // Set the body of the message.
        amPropId[cProps]            = PROPID_M_BODY;
        aPropVar[cProps].vt         = VT_UI1 | VT_VECTOR;
        aPropVar[cProps].caub.cElems = sizeof(Buffer);
        aPropVar[cProps].caub.pElems = Buffer;
        cProps++;

        // Set the label of the message.
        amPropId[cProps]            = PROPID_M_LABEL;
        aPropVar[cProps].vt         = VT_LPWSTR;
        aPropVar[cProps].pwszVal    = wcsMsgLabel;
        cProps++;
        
        // Create a MSGPROPS structure.
        msgprops.cProp    = cProps;
        msgprops.aPropID  = amPropId;
        msgprops.aPropVar = aPropVar;
        msgprops.aStatus  = 0;


        //
        // Send the message.
        //
        hr = MQSendMessage(
                qhSend,     // IN: Queue handle
                &msgprops,  // IN: Message properties to send
                NULL);      // IN: Not part of a transaction

        if (FAILED(hr))
            Error("MQSendMessage failed", hr);

        //
        // Check for a request to end the application.
        //
        if (_stricmp(Buffer, "quit") == 0)
            break;

    } /* for */


    //
    // Close the queue handle.
    //
    MQCloseQueue(qhSend);
}
//-----------------------------------------------------
//
// Sender in domain (standard) mode
//
//-----------------------------------------------------
void StandardSender(void)
{
    DWORD         cProps;

    MQMSGPROPS    msgprops;
    MQPROPVARIANT aPropVar[MAX_VAR];
    QUEUEPROPID   aqPropId[MAX_VAR];
    MSGPROPID     amPropId[MAX_VAR];

    MQPROPERTYRESTRICTION aPropRestriction[MAX_VAR];
    MQRESTRICTION Restriction;

    MQCOLUMNSET      Column;
    HANDLE        hEnum;

    WCHAR         wcsFormat[MAX_FORMAT];

    UCHAR         Buffer[MAX_BUFFER];
    WCHAR         wcsMsgLabel[MQ_MAX_MSG_LABEL_LEN+1];

    DWORD         i;

    DWORD         cQueue;
    DWORD         dwNumChars;
    QUEUEHANDLE   aqh[MAX_VAR];

    HRESULT       hr;
	int			  nPos;


    printf("\nSender mode on the computer %s\n\n", mbsMachineName);


    //
    // Prepare parameters for locating queues.
    //

    //
    // 1. Restriction: Queues with PROPID_Q_TYPE = MSMQTest service type GUIID
    //
    cProps = 0;
    aPropRestriction[cProps].rel         = PREQ;
    aPropRestriction[cProps].prop        = PROPID_Q_TYPE;
    aPropRestriction[cProps].prval.vt    = VT_CLSID;
    aPropRestriction[cProps].prval.puuid = &guidMQTestType;
    cProps++;

    Restriction.cRes      = cProps;
    Restriction.paPropRes = aPropRestriction;


    //
    // 2. Columnset (the queue properties to retrieve) = queue GUID
    //
    cProps = 0;
    aqPropId[cProps] = PROPID_Q_INSTANCE;
    cProps++;

    Column.cCol = cProps;
    Column.aCol = aqPropId;


    //
    // Issue the query to locate the queues.
    //
    hr = MQLocateBegin(
             NULL,          // IN:  Context must be NULL
             &Restriction,  // IN:  Restriction
             &Column,       // IN:  Properties to return
             NULL,          // IN:  No need to sort
             &hEnum);       // OUT: Enumeration handle

    if (FAILED(hr))
        Error("MQLocateBegin failed", hr);

    //
    // Get the results (up to MAX_VAR).
    // (For more results, call MQLocateNext in a loop.)
    //
    cQueue = MAX_VAR;
    hr = MQLocateNext(
             hEnum,         // IN:     Enumeration handle
             &cQueue,       // IN/OUT: Number of properties
             aPropVar);     // OUT:    Properties of the queue located

    if (FAILED(hr))
        Error("MQLocateNext failed", hr);

    //
    // End the query and release the resouces associated with it.
    //
    hr = MQLocateEnd(hEnum);

    if (cQueue == 0)
    {
        //
        // No queue could be found, so exit.
        //
        printf("No queue was registered.");
        exit(0);
    }


    printf("\tQueue(s) found: %d\n", cQueue);


    //
    // Open a handle for each of the queues found.
    //
    for (i = 0; i < cQueue; i++)
    {
        // Convert the queue GUID to a format name.
        dwNumChars = MAX_FORMAT;
        hr = MQInstanceToFormatName(
                  aPropVar[i].puuid,    // IN:     Queue GUID
                  wcsFormat,            // OUT:    Format name
                  &dwNumChars);         // IN/OUT: Size of format name

        if (FAILED(hr))
            Error("MQInstanceToFormatName failed", hr);

        //
        // Open the queue with send access.
        //
        hr = MQOpenQueue(
                 wcsFormat,           // IN:  Queue format name
                 MQ_SEND_ACCESS,      // IN:  Want to send to queue
                 0,                   // IN:  Must be 0 for send access
                 &aqh[i]);            // OUT: Handle of open queue

        if (FAILED(hr))
            Error("MQOpenQueue failed", hr);

        //
        // Free the memory that was allocated for the queue GUID during the query.
        //
        MQFreeMemory(aPropVar[i].puuid);
    }


    printf("\nEnter \"quit\" to exit.\n");


    //
    // Construct the message label.
    //
	nPos = _snwprintf_s(
                   wcsMsgLabel, 
                   sizeof(wcsMsgLabel)/sizeof(wcsMsgLabel[0]), 
                   sizeof(wcsMsgLabel)/sizeof(wcsMsgLabel[0]) - 1, 
                   L"Message from %S", 
                   mbsMachineName
                   );
	if(nPos < 0)
	{
		printf("The label is too long for the buffer. Exiting...\n");
		exit(1);
	}	

    //
    // Main sender loop
    //
    for(;;)
    {
        //
        // Get a string from the console.
        //
        printf("Enter a string: ");
		if (fgets(Buffer, MAX_BUFFER - 1, stdin) == NULL)
            break;
		
		Buffer[MAX_BUFFER-1] = '\0';
		//
		// Deleting the new-line character.
		//
		if(Buffer[strlen(Buffer) - 1] == '\n')
		{
			Buffer[strlen(Buffer)-1] = '\0'; 
		}


        //
        // Prepare the message properties for sending messages.
        //
        cProps = 0;

        // Set the message body.
        amPropId[cProps]            = PROPID_M_BODY;
        aPropVar[cProps].vt         = VT_UI1 | VT_VECTOR;
        aPropVar[cProps].caub.cElems = sizeof(Buffer);
        aPropVar[cProps].caub.pElems = Buffer;
        cProps++;

        // Set the message label.
        amPropId[cProps]            = PROPID_M_LABEL;
        aPropVar[cProps].vt         = VT_LPWSTR;
        aPropVar[cProps].pwszVal    = wcsMsgLabel;
        cProps++;

        // Create a MSGPROPS structure.
        msgprops.cProp    = cProps;
        msgprops.aPropID  = amPropId;
        msgprops.aPropVar = aPropVar;
        msgprops.aStatus  = 0;


        //
        // Send the message to all the queues.
        //
        for (i = 0; i < cQueue; i++)
        {
            hr = MQSendMessage(
                    aqh[i],     // IN: Queue handle
                    &msgprops,  // IN: Message properties to send
                    NULL);      // IN: Not part of a transaction

            if (FAILED(hr))
                Error("MQSendMessage failed", hr);
        }

        //
        // Check for a request to end the application.
        //
        if (_stricmp(Buffer, "quit") == 0)
            break;

    } /* for */


    //
    // Close all the queue handles.
    //
    for (i = 0; i < cQueue; i++)
        MQCloseQueue(aqh[i]);

}
//--------------------------------------------------------
//
// Receiver Mode
// -------------
// The receiver side does the following:
//    1. Creates a queue on the local computer
//       of type "guidMQTestType".
//       The queue is either public or private, depending
//       on the connection we want to establish.
//    2. Opens the queue.
//    3. In a loop,
//          receives messages
//          and prints the message body and message label.
//    4. Cleans up handles.
//    5. Deletes the queue from the directory service.
//
//--------------------------------------------------------
void Receiver(int dDirectMode)
{

    MQQUEUEPROPS  qprops;
    MQMSGPROPS    msgprops;
    MQPROPVARIANT aPropVar[MAX_VAR];
    QUEUEPROPID   aqPropId[MAX_VAR];
    MSGPROPID     amPropId[MAX_VAR];
    DWORD         cProps;

    WCHAR         wcsFormat[MAX_FORMAT];

    UCHAR         Buffer[MAX_BUFFER];
    WCHAR         wcsMsgLabel[MQ_MAX_MSG_LABEL_LEN+1];
    WCHAR         wcsPathName[MAX_FORMAT];


    DWORD         dwNumChars;
    QUEUEHANDLE   qh;

    HRESULT       hr;
	int			  nPos;

    printf("\nReceiver Mode on Machine: %s\n\n", mbsMachineName);


    //
    // Set properties to create a queue on the local computer.
    //
    cProps = 0;

    // Set the path name.
    if(dDirectMode == DIRECT)  // Private queue path name
    {
		nPos = _snwprintf_s(
                           wcsPathName, 
                           sizeof(wcsPathName)/sizeof(wcsPathName[0]), 
                           sizeof(wcsPathName)/sizeof(wcsPathName[0]) - 1, 
                           L"%S\\private$\\MSMQTest", 
                           mbsMachineName
                           );
		if(nPos < 0)
		{
			printf("The path name is too long for the buffer. Exiting...\n");
			exit(1);
		}	

    }
    else                       // Public queue path name
    {    
		nPos = _snwprintf_s(
                           wcsPathName, 
                           sizeof(wcsPathName)/sizeof(wcsPathName[0]), 
                           sizeof(wcsPathName)/sizeof(wcsPathName[0]) - 1, 
                           L"%S\\MSMQTest", 
                           mbsMachineName
                           );
		if(nPos < 0)
		{
			printf("The path name is too long for the buffer. Exiting...\n");
			exit(1);
		}	

    }

    aqPropId[cProps]         = PROPID_Q_PATHNAME;
    aPropVar[cProps].vt      = VT_LPWSTR;
    aPropVar[cProps].pwszVal = wcsPathName;
    cProps++;

    // Specify the service type GUID of the queue.
    // (This property will be used to locate all the queues of this type.)
    aqPropId[cProps]         = PROPID_Q_TYPE;
    aPropVar[cProps].vt      = VT_CLSID;
    aPropVar[cProps].puuid   = &guidMQTestType;
    cProps++;

    // Add a descriptive label to the queue.
    // (A label is useful for administration through the MSMQ admin tools.)
    aqPropId[cProps]         = PROPID_Q_LABEL;
    aPropVar[cProps].vt      = VT_LPWSTR;
    aPropVar[cProps].pwszVal = L"Sample application of MSMQ SDK";
    cProps++;

    // Create a QUEUEPROPS structure.
    qprops.cProp    = cProps;
    qprops.aPropID  = aqPropId;
    qprops.aPropVar = aPropVar;
    qprops.aStatus  = 0;


    //
    // Create the queue.
    //
    dwNumChars = MAX_FORMAT;
    hr = MQCreateQueue(
            NULL,           // IN:     Default security
            &qprops,        // IN/OUT: Queue properties
            wcsFormat,      // OUT:    Format name
            &dwNumChars);   // IN/OUT: Size of the format name

    if (FAILED(hr))
    {
        //
        // API failed, but not because the queue exists.
        //
        if (hr != MQ_ERROR_QUEUE_EXISTS)
            Error("MQCreateQueue failed", hr);

        //
        // The queue exist, so get its format name.
        //
        printf("The queue already exists. Open it anyway.\n");

        if(dDirectMode == DIRECT)
        // It's a private queue, so we know its direct format name.
        {
			int n = _snwprintf_s(
                                    wcsFormat, 
                                    sizeof(wcsFormat)/sizeof(wcsFormat[0]), 
                                    sizeof(wcsFormat)/sizeof(wcsFormat[0]) - 1, 
                                    L"DIRECT=OS:%s", 
                                    wcsPathName);
			if(n < 0)
			{
				printf("The format name is too long for the buffer. Exiting...\n");
				exit(1);
			}	

        }
        else
        // It's a public queue, so we must get its format name from the DS.
        {
            dwNumChars = sizeof(wcsFormat)/sizeof(wcsFormat[0]);
            hr = MQPathNameToFormatName(
                       wcsPathName,     // IN:     Queue path name
                       wcsFormat,       // OUT:    Format name
                       &dwNumChars);    // IN/OUT: Size of the format name

            if (FAILED(hr))
                Error("The format name cannot be retrieved", hr);
        }
    }


    //
    // Open the queue with receive access.
    //
    hr = MQOpenQueue(
             wcsFormat,          // IN:  Queue format name
             MQ_RECEIVE_ACCESS,  // IN:  Want to receive from queue
             0,                  // IN:  Allow sharing
             &qh);               // OUT: Handle of open queue

    //
    // Things are a little bit tricky. MQCreateQueue succeeded, but in the 
    // case of a public queue, this does not mean that MQOpenQueue
    // will succeed, because replication delays are possible. The queue is
    // registered in the DS, but it might take a replication interval
    // until the replica reaches the server that I am connected to.
    // To overcome this, open the queue in a loop.
    //
    // In this specific case, this can happen only if this program
    // is run on an MSMQ 1.0 backup server controller (BSC) or on
    // a client connected to a BSC.
    // To be totally on the safe side, we should have put some code
    // to exit the loop after a few retries, but this is just a sample.
    //
    while (hr == MQ_ERROR_QUEUE_NOT_FOUND)
    {
       printf(".");

       // Wait a bit.
       Sleep(500);

       // Retry.
       hr = MQOpenQueue(wcsFormat, MQ_RECEIVE_ACCESS, 0, &qh);
    }

    if (FAILED(hr))
         Error("The queue cannot be opened", hr);


    //
    // Main receiver loop
    //
    if(dDirectMode == DIRECT)
    {
        printf("\n* Working in workgroup (direct) mode.\n");
    }
    printf("\n* Waiting for messages...\n");
    
    for(;;)
    {
        //
        // Set the message properties for reading messages.
        //
        cProps = 0;

        // Ask for the body of the message.
        amPropId[cProps]            = PROPID_M_BODY;
        aPropVar[cProps].vt         = VT_UI1 | VT_VECTOR;
        aPropVar[cProps].caub.cElems = sizeof(Buffer);
        aPropVar[cProps].caub.pElems = Buffer;
        cProps++;

        // Ask for the label of the message.
        amPropId[cProps]         = PROPID_M_LABEL;
        aPropVar[cProps].vt      = VT_LPWSTR;
        aPropVar[cProps].pwszVal = wcsMsgLabel;
        cProps++;

        // Ask for the length of the label of the message.
        amPropId[cProps]         = PROPID_M_LABEL_LEN;
        aPropVar[cProps].vt      = VT_UI4;
        aPropVar[cProps].ulVal   = sizeof(wcsMsgLabel);
        cProps++;

        // Create a MSGPROPS structure.
        msgprops.cProp    = cProps;
        msgprops.aPropID  = amPropId;
        msgprops.aPropVar = aPropVar;
        msgprops.aStatus  = 0;


        //
        // Receive the message.
        //
        hr = MQReceiveMessage(
               qh,                // IN:     Queue handle
               INFINITE,          // IN:     Time-out
               MQ_ACTION_RECEIVE, // IN:     Read operation
               &msgprops,         // IN/OUT: Message properties to retrieve
               NULL,              // IN/OUT: No OVERLAPPED structure
               NULL,              // IN:     No callback
               NULL,              // IN:     No cursor
               NULL);             // IN:     Not part of a transaction

        if (FAILED(hr))
            Error("MQReceiveMessage failed", hr);

        //
        // Display the received message.
        //
        printf("%S : %s\n", wcsMsgLabel, Buffer);

        //
        // Check for a request to end the application.
        //
        if (_stricmp(Buffer, "quit") == 0)
            break;

    } /* while (1) */

    //
    // Cleanup: Close the handle to the queue.
    //
    MQCloseQueue(qh);


    //
    // In the concluding stage, we delete the queue from the directory
    // service. (We don't need to do this. In case of a public queue, 
    // leaving it in the DS enables sender applications to send messages 
    // even if the receiver is not available.)
    //
    hr = MQDeleteQueue(wcsFormat);
    if (FAILED(hr))
        Error("The queue cannot be deleted", hr);
}
예제 #5
0
HRESULT MsmqQueue::openQueue(const char *szQueuePath, int openmode)
{
    WCHAR wszPathName[MQ_MAX_Q_NAME_LEN] = {0};
    long	accessmode = openmode;  // bit field: MQ_{RECEIVE,SEND,PEEK,ADMIN}_ACCESS, 
    long	sharemode = MQ_DENY_NONE;

    // Validate the input string.
    if (szQueuePath == NULL)
	{
	    return MQ_ERROR_INVALID_PARAMETER;
	}

    // convert to wide characters;
	int len = strlen(szQueuePath);
    if (MultiByteToWideChar(
			    CP_ACP,
			    0,
			    szQueuePath,
			    len,
			    wszPathName,
			    _countof(wszPathName) ) == 0)
	{
	    return MQ_ERROR_INVALID_PARAMETER;
	}
    if (len < _countof( wszPathName ) )
		wszPathName[len]= 0; // need this to terminate	
	

    HRESULT hr = MQ_OK;

    // dinoch Mon, 18 Apr 2005  16:12

      printf("open: ");
      printf("fmtname(%ls) ", wszPathName);
      printf("accessmode(%d) ", accessmode);
      printf("sharemode(%d) ", sharemode);
     printf("\n");

    hr = MQOpenQueue(
		     wszPathName,           // Format name of the queue
		     accessmode,		  // Access mode
		     sharemode,  	          // Share mode
		     &hQueue   	                  // OUT: Handle to queue
		     );
			 
    // Retry to handle AD replication delays. 
    //
    if (hr == MQ_ERROR_QUEUE_NOT_FOUND)
	{
	    int iCount = 0 ;
	    while((hr == MQ_ERROR_QUEUE_NOT_FOUND) && (iCount < 120))
		{
		    printf(".");

		    // Wait a bit.
		    iCount++ ;
		    Sleep(50);

		    // Retry.
		    hr = MQOpenQueue(wszPathName, 
				     accessmode,
				     sharemode,
				     &hQueue);
		}
	}

    if (FAILED(hr))
	{
	    MQCloseQueue(hQueue);
	}

    return hr;

};
예제 #6
0
BOOL CDisdrawDlg::OpenPrivateReceiveQueue()
{ 
   
    //
    // Compose the pathname to the receiving queue and make it private.
    //
    char mbsPathName[MQ_MAX_Q_NAME_LEN+1];
    DWORD dwNumChars = sizeof(mbsPathName);
    GetComputerName(mbsPathName, &dwNumChars);
    strcat_s(mbsPathName, sizeof(mbsPathName), "\\");
    strcat_s(mbsPathName, sizeof(mbsPathName), "private$");
    strcat_s(mbsPathName, sizeof(mbsPathName), "\\");
    strcat_s(mbsPathName, sizeof(mbsPathName), m_strLogin);


    //
    // Prepare the properties of the receiving queue.
    //
    DWORD cProps = 0;
    QUEUEPROPID  aPropId[3];
    MQPROPVARIANT aPropVar[3];
	MQQUEUEPROPS propsQueue;
	
	WCHAR wcsPathName[MQ_MAX_Q_NAME_LEN+1];
        size_t nResultedStringLength=0;
	mbstowcs_s(
            &nResultedStringLength,
            wcsPathName, 
            sizeof(wcsPathName)/sizeof(wcsPathName[0]),
            mbsPathName, 
            sizeof(wcsPathName)/sizeof(wcsPathName[0])-1
            );
	aPropId[cProps]			 = PROPID_Q_PATHNAME;
	aPropVar[cProps].vt		 = VT_LPWSTR;
	aPropVar[cProps].pwszVal = wcsPathName;
	cProps++;

	aPropId[cProps]			 = PROPID_Q_TYPE;
	aPropVar[cProps].vt		 = VT_CLSID;
	aPropVar[cProps].puuid	 = &guidDrawType;
	cProps++;

	WCHAR wcsLabel[MQ_MAX_Q_LABEL_LEN+1];
        nResultedStringLength=0;
	mbstowcs_s(
            &nResultedStringLength,
            wcsLabel, 
            sizeof(wcsLabel)/sizeof(wcsLabel[0]),
            m_strLogin, 
            sizeof(wcsLabel)/sizeof(wcsLabel[0])-1
            );
	aPropId[cProps]			 = PROPID_Q_LABEL;
	aPropVar[cProps].vt		 = VT_LPWSTR;
	aPropVar[cProps].pwszVal = wcsLabel;
	cProps++;

	propsQueue.cProp	= cProps;
	propsQueue.aPropID	= aPropId;
	propsQueue.aPropVar = aPropVar;
	propsQueue.aStatus	= NULL;


	//
	// Create the receiving queue.
	//
    WCHAR wcsFormatName[MAX_FORMAT_NAME_LEN+1];
	dwNumChars = sizeof(wcsFormatName)/sizeof(wcsFormatName[0]);
	HRESULT hr = MQCreateQueue(NULL, &propsQueue, wcsFormatName, &dwNumChars);


	if (FAILED(hr) && hr != MQ_ERROR_QUEUE_EXISTS)
    {
		return FALSE;
    }


    if( hr ==  MQ_ERROR_QUEUE_EXISTS)
    {
       	//
    	// If the receiving queue already exists, obtain its format name.
	    //
        
        WCHAR wcsLoginName[MQ_MAX_Q_NAME_LEN+1];
        nResultedStringLength=0;
	mbstowcs_s(
            &nResultedStringLength,
            wcsLoginName, 
            sizeof(wcsLoginName)/sizeof(wcsLoginName[0]),
            m_strLogin, 
            sizeof(wcsLoginName)/sizeof(wcsLoginName[0])-1
            );
        swprintf_s(wcsFormatName, sizeof(wcsFormatName)/sizeof(wcsFormatName[0]), L"DIRECT=OS:.\\private$\\%s",wcsLoginName);

    }

   	//
	// Open the receiving queue (a local private queue).
	//

	hr = MQOpenQueue(wcsFormatName, 
                             MQ_RECEIVE_ACCESS, 
                             MQ_DENY_NONE , 
                             &m_hqIncoming);

	if (FAILED(hr))
    {
		return FALSE;
    }
    return TRUE;

}
예제 #7
0
void CDisdrawDlg::OnButtonAttach() 
{

    //
    // The constructor changes the cursor to an hourglass.
    // When the object goes out of scope, the cursor changes back to normal.
    //
    CWaitCursor wait ;
    WCHAR wcsFormatName[MAX_FORMAT_NAME_LEN+1];

	if(m_fDsEnabledLocaly && m_iRadioDS == 0) 
    {
        //
        // Connect with a remote computer in standard mode. 
        //
        
        //
	    // Obtain the name of the friend queue.
	    //
	    UpdateData(TRUE);
	    m_strFriend.MakeUpper();
        //
        // Make sure the friend queue exists.
        //
	    if (!LocateQueue(m_strFriend, wcsFormatName, sizeof(wcsFormatName)/sizeof(wcsFormatName[0])) )
	    {
		    AfxMessageBox("No such queue exists.");
		    return;
	    }
	    
        
    }
    else if(!m_fDsEnabledLocaly || m_iRadioDS == 1) 
    {
        //
        // Connect with a remote computer in direct mode. 
        //
        
        //
	    // Obtain the name of the friend queue and the remote computer.
	    //
	    UpdateData(TRUE);
	    m_strFriend.MakeUpper();
        m_strRemoteComputerName.MakeUpper();


        //
        // Make sure the friend queue exists. Since we are connecting to 
        // a private queue, we cannot obtain its format name from the
        // directory service (DS), so we will asuume it exists and try to open it.
        //
       
	    //
	    // Open the friend queue for sending (in direct mode)
        // Please Note:
        // Opening a remote queue for sending will always  
        // succeed even if the queue or computer does not exist.
        // When working in direct mode, we must use private queues. 
        // We cannot know whether a given private queue on another computer exists or not,
        // so here we will just assume that it does. To make the application more robust,
        // an acknowledgement queue should be created on the local computer, and
        // a request for acknowledgement messages should be added to the messages sent.
        // Then the application can notify the user when a negative adknowledgement message
        // (NACK) is received.
        //

   
        //
        // Compose the format name.
        //
        char mbsFormatName[MAX_FORMAT_NAME_LEN+1];
        sprintf_s(mbsFormatName, sizeof(mbsFormatName), "DIRECT=OS:%s\\private$\\%s",m_strRemoteComputerName,m_strFriend);
        size_t nResultedStringLength=0;
        mbstowcs_s(
            &nResultedStringLength,
            wcsFormatName,
            sizeof(wcsFormatName)/sizeof(wcsFormatName[0]),
            mbsFormatName,
            sizeof(mbsFormatName)-1
            );

    }

    //
	// Open the remote queue for sending.
    // The action is the same in both cases.
	//
	HANDLE hqNewFriend;
	HRESULT hr = MQOpenQueue(wcsFormatName, MQ_SEND_ACCESS, MQ_DENY_NONE , &hqNewFriend);
	if (FAILED(hr))
		AfxMessageBox("The remote queue cannot be opened.");

	else
	{
		//
		// Close the previous friend queue and update the title bar.
		//
		if (m_hqOutgoing != NULL)
        {
			MQCloseQueue(m_hqOutgoing);
        }
		m_hqOutgoing = hqNewFriend;
		CString strTitle = m_strLogin + " connected to " + m_strFriend;
		SetWindowText(strTitle);
		m_btnAttach.EnableWindow(FALSE);
	}
    
}
예제 #8
0
BOOL CDisdrawDlg::OpenReceiveQueue()
{
    //
    // Do not create the receiving queue if it already exists in the enterprise.
    //
    HRESULT hr;
	WCHAR wcsFormatName[MAX_FORMAT_NAME_LEN+1];
    if (!LocateQueue(m_strLogin, wcsFormatName, sizeof(wcsFormatName)/sizeof(wcsFormatName[0])))
    {
    	//
    	// Form the pathname of the receiving queue.
    	//
    	char mbsPathName[MQ_MAX_Q_NAME_LEN+1];
    	DWORD dwNumChars = sizeof(mbsPathName);
    	GetComputerName(mbsPathName, &dwNumChars);
	strcat_s(mbsPathName, sizeof(mbsPathName), "\\");
        strcat_s(mbsPathName, sizeof(mbsPathName), m_strLogin);


    	//
    	// Prepare the receiving queue properties.
    	//
    	DWORD cProps = 0;
    	QUEUEPROPID  aPropId[3];
    	MQPROPVARIANT aPropVar[3];
	    MQQUEUEPROPS propsQueue;
	    
		WCHAR wcsPathName[MQ_MAX_Q_NAME_LEN+1];
                size_t nResultedStringLength=0;
		mbstowcs_s(
                    &nResultedStringLength,
                    wcsPathName, 
                    sizeof(wcsPathName)/sizeof(wcsPathName[0]),
                    mbsPathName, 
                    sizeof(wcsPathName)/sizeof(wcsPathName[0])-1
                    );
	    aPropId[cProps]			 = PROPID_Q_PATHNAME;
	    aPropVar[cProps].vt		 = VT_LPWSTR;
	    aPropVar[cProps].pwszVal = wcsPathName;
	    cProps++;

	    aPropId[cProps]			 = PROPID_Q_TYPE;
	    aPropVar[cProps].vt		 = VT_CLSID;
	    aPropVar[cProps].puuid	 = &guidDrawType;
	    cProps++;

		WCHAR wcsLabel[MQ_MAX_Q_LABEL_LEN+1];
                nResultedStringLength=0;
		mbstowcs_s(
                    &nResultedStringLength,
                    wcsLabel, 
                    sizeof(wcsLabel)/sizeof(wcsLabel[0]),
                    m_strLogin, 
                    sizeof(wcsLabel)/sizeof(wcsLabel[0])-1
                    );
	    aPropId[cProps]			 = PROPID_Q_LABEL;
	    aPropVar[cProps].vt		 = VT_LPWSTR;
	    aPropVar[cProps].pwszVal = wcsLabel;
	    cProps++;

	    propsQueue.cProp	= cProps;
	    propsQueue.aPropID	= aPropId;
	    propsQueue.aPropVar = aPropVar;
	    propsQueue.aStatus	= NULL;


	    //
	    // Create the receiving queue.
	    //
	    dwNumChars = sizeof(wcsFormatName)/sizeof(wcsFormatName[0]);
	    hr = MQCreateQueue(NULL, &propsQueue, wcsFormatName, &dwNumChars);	


	    //
	    // If the receiving queue already exists, obtain its format name.
	    //
	    if (hr == MQ_ERROR_QUEUE_EXISTS)
            {
         	    dwNumChars = sizeof(wcsFormatName)/sizeof(wcsFormatName[0]);
		    hr = MQPathNameToFormatName(wcsPathName, wcsFormatName, &dwNumChars);
            }

	    if (FAILED(hr))
		    return FALSE;
    }

	//
	// Open the receiving queue (it may be necessary to retry due to replication latency).
	//
    int iCount = 0;
	while ((hr = MQOpenQueue(wcsFormatName, 
                             MQ_RECEIVE_ACCESS, 
                             MQ_DENY_NONE ,
                             &m_hqIncoming)) == MQ_ERROR_QUEUE_NOT_FOUND)
    {
		
        Sleep (500);
        iCount++;
        if (iCount >=30)
        {
            //
            // A period of 15 seconds past without locating the queue.
            // We allow the user to stop attempts to open the queue.
            //
            int iRes = MessageBox("The receiving queue was not located.\nDo you want to continue searching?",
                                NULL,
                                MB_YESNO);
            if(iRes == IDYES)
            {
                //
                // Continue searching.
                //
                iCount =0;
            }
            else
            {
                //
                // Stop searching.
                //
                break;
            }
        }
    }

	if (FAILED(hr))
		return FALSE;


	return TRUE;
}