Windows Dev Center

C/C++ Code Example: Opening a Private Queue Using a Computer Identifier and Queue Number

This example provides an application-defined function that opens a private queue based on the local computer using its computer identifier and a queue number provided by the caller.

The caller can obtain the queue number from the names of the LQSfiles stored in the Lqs folder (the Lqs folder is created when MSMQ is installed) on the computer. The queue number is the first part of the name of each file.

The following procedure shows how the function opens the queue based on the information provided by the caller.

To open a queue using a computer identifier and queue number

  1. Define the maximum number of properties to be specified, property counter and the MQQMPROPS structure. In this example the computer identifier property is the only property specified.

  2. Specify the PROPID_QM_MACHINE_ID computer property

  3. Initialize the MQQMPROPS structure.

  4. Call MQGetMachineProperties to retrieve the globally unique identifier (GUID) of the computer. The following code example retrieves the GUID of the local computer.

  5. Construct a private format name for the queue using the computer GUID returned by MQGetMachineProperties and the provided queue number. (This example uses the RPC function UuidToString to construct the format of the private queue.)

    The syntax of the private format name is shown below:

    "PRIVATE=ComputerGUID\QueueNumber"
    
  6. Using the constructed format name and the access and share modes provided in the call, call MQOpenQueue to open the queue.

Code Example

The library and header files required for the RPC calls made by this function are rpcrt4.lib and rpc.h, respectively. This function contains no version-specific Message Queuing calls.

HRESULT OpenMyQueue(
                    CHAR szQueueNumber[]
                    )
{
  
  HRESULT hr = MQ_OK;                  // Return code

  
  // Define the maximum number of properties, a property counter, and 
  // an MQQMPROPS structure.
  const int NUMBEROFPROPERTIES = 1;                   // Number of computer properties
  DWORD cPropId=0;                                    // Property counter

  MQQMPROPS qmprops;
  QMPROPID aQMPropId[NUMBEROFPROPERTIES];
  MQPROPVARIANT aQMPropVar[NUMBEROFPROPERTIES];
  HRESULT aQMStatus[NUMBEROFPROPERTIES];
  

  // Specify PROPID_QM_MACHINE_ID.
  CLSID guidMachineId;                                // Computer GUID buffer
  aQMPropId[cPropId] = PROPID_QM_MACHINE_ID;          // Property ID
  aQMPropVar[cPropId].vt = VT_CLSID;                  // Type indicator
  aQMPropVar[cPropId].puuid = &guidMachineId;         // Computer GUID buffer
  cPropId++;
  
  
  // Initialize the MQQMPROPS structure.
  qmprops.cProp = cPropId;                            // Number of properties
  qmprops.aPropID = aQMPropId;                        // IDs of the properties
  qmprops.aPropVar = aQMPropVar;                      // Values of the properties
  qmprops.aStatus = aQMStatus;                        // Error reports
  
  
  // Call MQGetMachineProperties to retrieve the 
  // GUID of the computer where the queue is registered.
  hr = MQGetMachineProperties(NULL,
                              NULL,
                              &qmprops);
  if (FAILED(hr))
  {
     fprintf(stderr, "An error occurred in MQGetMachineProperties (error: 0x%x).\n",hr);
     return hr;
  }
  
  
  // Construct the format name of the private queue. The returned 
  // computer GUID is translated into a string and then combined 
  // with the queue number.
  UCHAR *pszUuid = 0;                     // Computer GUID string
  CHAR szFormatNameBuffer[256];           // Format name buffer
  WCHAR wszFormatNameBuffer[256];         // Wide-character format name buffer

  if (UuidToString(&guidMachineId, &pszUuid) != RPC_S_OK)
  {
     fprintf(stderr, "An error occurred in UuidToString.\n");
     return E_FAIL;
  }
  else
  {
    // Combine the computer ID and queue number.
  // ************************************
  // You must concatenate "PRIVATE=", pszUuid, "\", pszUuid, and
  // szQueueNumber into the szFormatNameBuffer buffer.
  // szFormatNameBuffer = "PRIVATE=" + pszUuid + "\" + pszUuid + 
  // szQueueNumber
  // If the format name is too long for the buffer, return S_FALSE.
  // ************************************
   
   // Convert the format name to a wide-character string.
     mbstowcs(wszFormatNameBuffer,
             szFormatNameBuffer,
             sizeof(szFormatNameBuffer));
  RpcStringFree(&pszUuid);
  }
  
  
  // Open the queue.
  QUEUEHANDLE hQueue = NULL;               // Handle of the created queue
  DWORD dwAccess = MQ_SEND_ACCESS;         // Access mode of the queue
  DWORD dwShareMode = MQ_DENY_NONE;        // Share mode of the queue
  
  hr = MQOpenQueue(
                   wszFormatNameBuffer,    // Format name of the queue
                   dwAccess,               // Access mode
                   dwShareMode,            // Share mode
                   &hQueue                 // OUT: Queue handle
                   );
  if (FAILED(hr))
  {
     fprintf(stderr, "An error occurred in MQOpenQueue (error: 0x%x).\n",hr);
     return hr;
  }
  puts("The queue is opened to send messages.");
  return hr;
}
Show:
© 2015 Microsoft