Interfacing with IBM WebSphere MQ (formally IBM MQSeries) from .NET

1. Who should read this article?

This article is targeting architects and developers who are looking for a way to integrate .NET applications / Servers with IBM WebSphere MQ (IBM MQSeries).

2. What to read?

This article is designed to provide a basic understanding of messaging from IBM perspective through the explanation of some basic functionalities of WebSphere MQ. The document is divided into three main parts:

a. Introduction to messaging: this is covered in sections 3 - 4.5. You can skip this part if you have a past experience with MSMQ.

b. Interacting with WebSphere MQ: this is covered in sections 4.6 - 8, and will provide you with sufficient knowledge that will allow you to interact with WebSphere MQ (IBM MQSeries).

c. Appendixes: this is covered in section 9, and to be used as a reference for part two.

3. Introduction:

Message queuing has been used in data processing for many years. It is most commonly used today in electronic mail. Without queuing, sending an electronic message over long distances requires every node on the route to be available for forwarding messages, and aware of the fact that you are trying to send them a message. In a queuing system, messages are stored at intermediate nodes until the system is ready to forward them or process them.

Even so, many complex business transactions are processed today without queuing. If this is the case; then why do we need queuing? Think about a system consisting of multiple nodes, where those nodes need to communicate with each other. If one node of the system suffers a problem, many nodes could become unusable.

In a message queuing environment, each program from the set that makes up the system is designed to perform a well-defined, self-contained function in response to a specific request. To communicate with another program, a program must put a message on a predefined queue. The other program retrieves the message from the queue, and processes the message. So message queuing is a style of program-to-program communication.

Queuing is the mechanism by which messages are held until an application is ready to process them. Queuing allows you to:

• Communicate between programs (which may each be running in different environments) without having to write the communication code.
• Select the order in which a program processes messages.
• Balance loads on a system by arranging for more than one program to service a queue when the number of messages exceeds a threshold.
• Increase the availability of your applications by arranging for an alternative system to service the queues if your primary system is unavailable.

4. Messaging

4.1. What is a message?

In message queuing, a message is simply a collection of data sent by one program and intended for another program. WebSphere MQ primarily defines four types of message:

1. Datagram: A simple message for which no reply is expected
2. Request: A message for which a reply is expected
3. Reply: A reply to a request message
4. Report: A message that describes an event such as the occurrence of an error.

In this article will be talking about type 2 and 3 of messages. Type 1 and 4 are out of scope.

4.2. Message descriptor

A message consists of control information and application data. The control information is defined in a message descriptor structure (MQMD) and contains things like:

• The type of the message
• An identifier for the message
• The priority for delivery of the message

The structure and content of the application data is determined by the participating programs, not by WebSphere MQ.

4.3. What is a message queue?

A message queue, referred to as a queue, is a named destination to which messages can be sent. Messages accumulate on queues until they are retrieved by programs that service those queues. Queues reside in, and are managed by, a queue manager. A queue can either be a volatile buffer area in the memory of a computer, or a data set on a permanent storage device, such as a disk. The physical management of queues is the responsibility of the queue manager and is not made apparent to the participating application programs.

Programs access queues only through queue manager. They can open a queue, put messages, get messages, and they can close the queue. They can also set, and inquire about, the attributes of queues.

4.4. What is a queue manager?

A queue manager is a system program that provides queuing services to applications. It exposes an API that would allow programs to put, and get messages from queues. A queue manager provides additional functions that would provide administrators with the ability to create new queues, alter the properties of existing ones, and control the operation of the queue manager.

For the queuing services to be available on a system; there must be a queue manager running On OS/400, z/OS, OS/2, Windows systems, UNIX, or some other supported operating system. You can have more than one queue manager running on a single system (for example, to separate the testing environment from the production one). To an application, each queue manager is identified by a connection handle (Hconn).

Many different applications can make use of the queue manager’s services at the same time and these applications can be entirely unrelated. For a program to use the services of a queue manager, it must establish a connection to that queue manager. For applications to be able to send messages to applications that are connected to other queue managers, queue managers must be able to communicate among themselves. WebSphere achieved this by implementing a store-and-forward protocol to ensure the safe delivery of messages between such applications.

4.5. Messages

There are four types of message defined by WebSphere MQ:

· Datagram

· Request

· Reply

· Report

Applications can use the first three types of messages to pass information between themselves. The fourth type, report, is for applications and queue managers to report information about events such as the occurrence of an error.

4.1.1. Datagrams

You should use a datagram when you do not require a reply from the application that receives the message. An example of an application that could use datagrams is one that displays flight information on the airport screens periodically.

4.1.2. Request messages

You should use a request message when you expect a reply from the application that receives the message. An example of an application that could use request messages is one that displays the balance of an account. The request message could contain the number of the account, and the reply message would contain the account balance. If you want to link your reply message with your request message, there are two options:

• You can give the application that handles the request message the responsibility of ensuring that it puts information into the reply message that relates to the request message.
• You can use the report field in the message descriptor of your request message to specify the content of the MsgId and CorrelId fields of the reply message:

• You can request that either the MsgId or the CorrelId of the original message is to be copied into the CorrelId field of the reply message (the default action is to copy MsgId).
• You can request that either a new MsgId is generated for the reply message, or that the MsgId of the original message is to be copied into the MsgId field of the reply message (the default action is to generate a new message identifier).

4.1.3. Reply messages

You should use a reply message when you reply to another message. When you create a reply message, you should respect any options that were set in the message descriptor of the message to which you are replying. Report options specify the content of the message identifier (MsgId) and correlation identifier (CorrelId) fields. These fields allow the application that receives the reply to correlate the reply with its original request.

4.1.4. Report messages

Report messages inform applications about events such as the occurrence of an error when processing a message. They can be generated by:

• A queue manager,
• A message channel agent (for example, if they cannot deliver the message), or
• An application (for example, if it cannot use the data in the message).

Note that report messages can be generated at any time, and they may arrive on a queue when your application is not expecting them.

4.1.5. Correlating replies

In WebSphere MQ applications, when a program receives a message that asks it to do some work, the program usually sends one or more reply messages to the requester. To help the requester to associate these replies with its original request, an application can set a correlation identifier field in the descriptor of each message. Programs should copy the message identifier of the request message into the correlation identifier field of their reply messages.

4.6. Channels

A channel is a communication link used by queue managers. There are two categories of channel in WebSphere MQ, and we can describe them as control channels and data channels:

• 
  Message channels, which are unidirectional, and transfer messages from one queue manager to another.
  
• 
  Message Queue Interface (MQI) channels, which are bidirectional, and transfer control calls from a WebSphere MQ client to a queue manager, and responses from a queue manager to a WebSphere MQ client. We will not spend more time on this part since it is out of the scope of this article.
  

5. WebSphere MQ Object Model:

The WebSphere MQ Object Model consists of the following:

• Classes representing MQ concepts such as queue managers, queues, and messages.
• Methods on each class corresponding to MQI calls.
• Properties on each class corresponding to attributes of MQ objects.

And provides the following set of classes:

Class Name	Description
MQQueueManager	An object of the MQQueueManager class represents a connection to a queue manager. It has methods to Connect(), Disconnect(), Commit(), and Backout() or what we call “rollback” . It has properties corresponding to the attributes of a queue manager. Note that accessing a queue manager attribute property implicitly connects to the queue manager if not already connected.
MQQueue	An object of the MQQueue class represents a queue. It has methods to Put() and Get() messages to and from the queue. It has properties corresponding to the attributes of a queue. Note that accessing a queue attribute property, or issuing a Put() or Get() method call, implicitly opens the queue.
MQMessage	An object of the MQMessage class represents a message to be placed on a queue or to be retrieved from a queue. It encapsulates both application data and MQMD, along with having properties corresponding to MQMD fields, and methods that allow you to write and read user data of different types (for example, strings, long integers, short integers, byte).
MQPutMessageOptions	An object of the MQPutMessageOptions class represents the MQPMO structure. It has properties corresponding to MQPMO fields.
MQGetMessageOptions	An object of the MQGetMessageOptions class represents the MQGMO structure. It has properties corresponding to MQGMO fields.

6. WebSphere MQ client:

A WebSphere MQ client is part of the WebSphere MQ product that can be installed on a separate machine from the base product and server and acts as a proxy between that machine and the server. You can run a WebSphere MQ application on a WebSphere MQ client and it can interact with one or more WebSphere MQ servers and connect to their queue managers by means of a communications protocol.

The MQI is available to applications running on the client platform; the queues and other WebSphere MQ objects are held on a queue manager that you have installed on a server machine. An application that you want to run in the WebSphere MQ client environment must first be linked with the relevant client library. When the application issues an MQI call, the WebSphere MQ client directs the request to a queue manager, where it is processed and from where a reply is sent back to the WebSphere MQ client.

6.1. How the client connects to the server

An application running in the WebSphere MQ client environment runs in synchronous mode because there must be an active connection between the client and the server machines. The connection is made by an application issuing an MQCONN or MQCONNX calls. Clients and servers communicate through MQI channels. When the call succeeds, the MQI channel remains connected until the application issues a MQDISC call. This is the case for every queue manager that an application needs to connect to.

6.2. Why use WebSphere MQ clients?

Using WebSphere MQ clients is an efficient way of implementing WebSphere MQ messaging and queuing.

You can have an application that uses the MQI running on one machine and the queue manager running on a different machine. The benefits of doing this are:

• There is no need for a full WebSphere MQ implementation on the client machine; for example, it could be a DOS, Windows 3.1, Windows 95, Windows 98, Windows XP, Windows 2k, or Windows 2k3 system.
• Hardware requirements on the client system are reduced.
• System administration requirements are reduced.
• A WebSphere MQ application running on a client can connect to multiple queue managers on different systems.

7. We saw the players, so let’s start the game:

Before you become able to send and receive messages to and from MQSeries; you need to install a set of applications and do some simple configurations. You need to install:

- .NET Framework (v1.1.4322 or later).

- WebSphere MQ client V 5.2 or above.

- WebSphere MQ classes for Microsoft .NET.

After installing the software you need to go and configure the MQ client. There are multiple ways of performing the configurations; the easiest and most straight forward one is by adding a system wide environment variable called MQSERVER and assigning to it the channel name, protocol used, server address and port in the following format:

MQSERVER=ChannelName/Protocol/server_address(port)

For example:

MQSERVER=GI_HUB_SVCON/TCP/172.21.106.14(1414).

To perform this on windows-XP right-click on my computer and select properties, then click over the Advanced tab.

Then click on the Environment Variables button.

Under system variables, click on the New button; a screen will popup asking you to provide the variable name and its value.

Then click over the OK button. Remember to restart the machine or the system will not be able to catch the variable you’ve just added.

Below you will find a ready-to-use class with comments showing you how to drop and receive messages from WebSphere MQ. All what you have to do is to add a reference to IBM.WMQ namespace which exists in amqmdnet.dll, if you install MQ client on the default directory; you will find amqmdnet.dll under C:\Program Files\MQSeries Client\bin.

One of the annoying things about the .NET implementation is that whenever the system raise an exception and you examined the “CompCode” (stands for completion code), and “Reason” properties of the MQException object, they will always provide you with a number that you have to lookup to know exactly what went wrong.

CompCode can have one of three values:

0 : Successful completion.

1 : Warning (partial completion).

2 : Call failed

When the value of CompCode is not equal to 0 you need to go and examine the Reason property which will give you another number that you can lookup in Appendix B for a basic explanation of the code, for more details you can refer to IBM WebSphere Messages Document.

8. The Code:

This code can be used whenever a need arise to interface with WebSphere MQ from a .NET client code. Those clients include but not limited to BizTalk 2004, CMS 2002, SPS 2003, or any custom .NET application. It has been tested with Windows-XP and Windows 2003 and in both cases it was working without problems.

/////////////////////////////////////////////////////////////////////
// Author : 
// E-mail : 
// Date : May - 2004
// Description : This class acts as a simple interface between any 
// .net application and IBM MQseries (WebSphere MQ)
//
/////////////////////////////////////////////////////////////////////
using System;
using IBM.WMQ;
using System.IO ;
using System.Text ;
namespace SHB.CB2B
{
public enum MessagingType
{
ASync,
Sync
}
public class MQAdapter
{
    // The name of the queue manager.
    private string QueManager;
    // The name of the queue where you will be dropping your messages.
    private string InQueName;
    // The name of the queue where you will be getting your messages.
    private string OutQueName;
    // The time you want a thread to wait on
    // an empty queue until a relevant message shows up.
    private int WaitInterval;
    private MQQueueManager qMgr;
    private MQQueue InputQueue;
    private MQQueue OutputQueue;
    private MQMessage MqsMsg;
    private MQMessage retrievedMessage;
    private MQGetMessageOptions gmo;
    private String msgText;
    private UTF8Encoding utf8Enc;
    public MQAdapter(MessagingType Type)
    {
        if (Type == MessagingType.ASync)
        {
            try
            {
                QMgr = new MQQueueManager(QueManager);
            }
            catch (MQException ex)
            {
                // Add your MQSeries exception handling here 
            }
        }
    }

    public string SendRequestToMQ(string RequestStream)
    {
        try
        {
            qMgr =new MQQueueManager(QueManager); 
            int InOpenOptions = MQC.MQOO_OUTPUT | 
                                MQC.MQOO_FAIL_IF_QUIESCING ;
            int OutOpenOptions = MQC.MQOO_INPUT_AS_Q_DEF | 
                                 MQC.MQOO_FAIL_IF_QUIESCING ;
            InputQueue = qMgr.AccessQueue(InQueName, InOpenOptions);
            OutputQueue = qMgr.AccessQueue(OutQueName, OutOpenOptions);
            MqsMsg =new MQMessage();
            // Since .NET strings stores characters encoded
            // in a UTF-16 format, while a major portion
            // of the applications using IBM MQSeries are legacy
            // application, you might need to encode strings
            // in a UTF-8, or ASCII format in order for
            // the applications on the other side to be able
            // to understand your messages
            utf8Enc = new UTF8Encoding();
            MqsMsg.WriteBytes(Encoding.UTF8.GetBytes(RequestStream)); 
            MQPutMessageOptions pmo =new MQPutMessageOptions(); 
            InputQueue.Put(MqsMsg,pmo);
        }
        catch (MQException ex)
        {
            // Add your MQSeries exception handling here
        }
        catch (Exception e)
        {
            // Add your exception handling here
            // to handle exceptions of types other than MQException
        }
        try
        {
            retrievedMessage =new MQMessage(); 
            retrievedMessage.CorrelationId =MqsMsg.MessageId;
            //Setting the get message options.. 
            gmo =new MQGetMessageOptions(); 
            // In order to activate "Wait on an empty queue";
            // you have to mask MQGetMessageOptions with MQGMO_WAIT 
            // for more details on other available options kindly refer to Appendix A
            gmo.Options = MQC.MQGMO_FAIL_IF_QUIESCING | MQC.MQGMO_WAIT ;
            gmo.WaitInterval = WaitInterval ;// wait time
            // to match using CorrelationID
            // or MQMO_MATCH_MSG_ID to match using MessageID
            gmo.MatchOptions = MQC.MQMO_MATCH_CORREL_ID ;
            OutputQueue.Get(retrievedMessage, gmo); 
            //writing Message result 
            msgText =retrievedMessage.ReadString(retrievedMessage.MessageLength) ;
        }
        catch (MQException ex)
        {
            // Add your MQSeries exception handling here 
        }
        catch (Exception e)
        {
            // Add your exception handling here to
            // handle exceptions of types other than MQException
        }
        try
        {
            //Close the queue 
            OutputQueue.Close();
            InputQueue.Close() ;
            //Disconnect from the queue manager 
            qMgr.Disconnect();
        }
        catch (MQException ex) 
        {
            // Add your MQSeries exception handling here 
        }
        catch (Exception e)
        {
            // Add your exception handling here
            // to handle exceptions of types other than MQException
        }
        return msgText;
    }
    // --------- See the comments one the code above --------//
    public Byte[] SendMessage(string Message)
    {
        int InOpenOptions ;
        MQQueue InputQueue = null ;
        MQMessage MqsMsg ;
        UTF8Encoding utf8Enc ;
        MQPutMessageOptions Pmo ;
        InOpenOptions = MQC.MQOO_OUTPUT | MQC.MQOO_FAIL_IF_QUIESCING ; 
        try
        {
            InputQueue = qMgr.AccessQueue(InQueName, InOpenOptions); 
            MqsMsg =new MQMessage(); 
            utf8Enc = new UTF8Encoding(); 
            MqsMsg.WriteBytes(utf8Enc.GetBytes(Message));
            Pmo =new MQPutMessageOptions(); 
            InputQueue.Put(MqsMsg,Pmo);
        } 
        catch (MQException ex)
        {
            // Add your MQSeries exception handling here
        }
        catch (System.Exception e)
        {
            // Add your exception handling here
            // to handle exceptions of types other than MQException
        }
        finally
        {
            InputQueue.Close() ;
        }
        return MqsMsg.MessageId ;
    }

    public string GetMessage(Byte[] MessageId)
    {
        int OutOpenOptions ;
        MQQueue OutputQueue = null ;
        MQMessage RetrievedMessage ;
        MQGetMessageOptions Gmo ;
        OutOpenOptions = MQC.MQOO_INPUT_AS_Q_DEF | 
                         MQC.MQOO_FAIL_IF_QUIESCING ; 
        RetrievedMessage =new MQMessage(); 
        Gmo =new MQGetMessageOptions(); 
        Gmo.Options = MQC.MQGMO_FAIL_IF_QUIESCING | 
                      MQC.MQGMO_WAIT ;
        Gmo.WaitInterval = WaitInterval ;
        Gmo.MatchOptions = MQC.MQMO_MATCH_CORREL_ID ;
        try
        {
            OutputQueue = qMgr.AccessQueue(OutQueName, OutOpenOptions); 
            RetrievedMessage.CorrelationId = MessageId ;
            OutputQueue.Get(RetrievedMessage,Gmo); 
        }
        catch (MQException e)
        {
            // Add your MQSerie exception handling here 
        }
        catch (System.Exception e)
        {
            // Add your exception handling here
            // to handle exceptions of types other than MQException
        }
        finally
        {
            OutputQueue.Close() ;
        }
        return RetrievedMessage.ReadString(RetrievedMessage.MessageLength) ;
    }
    ~ MQAdapter()
    {
        try
        {
            qMgr.Close() ;
        }
        catch
        {
        }
    }
}

9. References:

1. WebSphere MQ Application Programming Guide

2. WebSphere MQ Application Programming Reference

3. WebSphere MQ Clients

4. WebSphere MQ Message

5. WebSphere MQ Using the Component Object Model Interface

10. Appendixes:

9.1. Appendix A - Queue Accessing Options:

Queue Access Options	Explanation
MQOO_INPUT_AS_Q_DEF	Open to get messages using queue-defined default.
MQOO_INPUT_SHARED	Open to get messages with shared access.
MQOO_INPUT_EXCLUSIVE	Open to get messages with exclusive access.
MQOO_BROWSE	Open to browse message.
MQOO_OUTPUT	Open to put messages.
MQOO_INQUIRE	Open for inquiry, required if you wish to query properties.
MQOO_SET	Open to set attributes, required if you wish to set properties.
MQOO_BIND_ON_OPEN	Bind handle to destination when queue is opened.
MQOO_BIND_NOT_FIXED	Do not bind to a specific destination.
MQOO_BIND_AS_Q_DEF	Use default binding for queue.
MQOO_SAVE_ALL_CONTEXT	Save context when message retrieved.
MQOO_PASS_IDENTITY_CONTEXT	Allow identity context to be passed.
MQOO_PASS_ALL_CONTEXT	Allow all contexts to be passed.
MQOO_SET_IDENTITY_CONTEXT	Allows identity context to be set.
MQOO_SET_ALL_CONTEXT	Allows all contexts to be set.
MQOO_ALTERNATE_USER_AUTHORITY	Validate with the specified user identifier.
MQOO_FAIL_IF_QUIESCING	Fail if the queue manager is quiescing.

9.2. Appendix B – Error & Reason Codes

Reason Code	Error Code
MQRC_NONE	0
MQRC_APPL_FIRST	900
MQRC_APPL_LAST	999
MQRC_ALIAS_BASE_Q_TYPE_ERROR	2001
MQRC_ALREADY_CONNECTED	2002
MQRC_BACKED_OUT	2003
MQRC_BUFFER_ERROR	2004
MQRC_BUFFER_LENGTH_ERROR	2005
MQRC_CHAR_ATTR_LENGTH_ERROR	2006
MQRC_CHAR_ATTRS_ERROR	2007
MQRC_CHAR_ATTRS_TOO_SHORT	2008
MQRC_CONNECTION_BROKEN	2009
MQRC_DATA_LENGTH_ERROR	2010
MQRC_DYNAMIC_Q_NAME_ERROR	2011
MQRC_ENVIRONMENT_ERROR	2012
MQRC_EXPIRY_ERROR	2013
MQRC_FEEDBACK_ERROR	2014
MQRC_GET_INHIBITED	2016
MQRC_HANDLE_NOT_AVAILABLE	2017
MQRC_HCONN_ERROR	2018
MQRC_HOBJ_ERROR	2019
MQRC_INHIBIT_VALUE_ERROR	2020
MQRC_INT_ATTR_COUNT_ERROR	2021
MQRC_INT_ATTR_COUNT_TOO_SMALL	2022
MQRC_INT_ATTRS_ARRAY_ERROR	2023
MQRC_SYNCPOINT_LIMIT_REACHED	2024
MQRC_MAX_CONNS_LIMIT_REACHED	2025
MQRC_MD_ERROR	2026
MQRC_MISSING_REPLY_TO_Q	2027
MQRC_MSG_TYPE_ERROR	2029
MQRC_MSG_TOO_BIG_FOR_Q	2030
MQRC_MSG_TOO_BIG_FOR_Q_MGR	2031
MQRC_NO_MSG_AVAILABLE	2033
MQRC_NO_MSG_UNDER_CURSOR	2034
MQRC_NOT_AUTHORIZED	2035
MQRC_NOT_OPEN_FOR_BROWSE	2036
MQRC_NOT_OPEN_FOR_INPUT	2037
MQRC_NOT_OPEN_FOR_INQUIRE	2038
MQRC_NOT_OPEN_FOR_OUTPUT	2039
MQRC_NOT_OPEN_FOR_SET	2040
MQRC_OBJECT_CHANGED	2041
MQRC_OBJECT_IN_USE	2042
MQRC_OBJECT_TYPE_ERROR	2043
MQRC_OD_ERROR	2044
MQRC_OPTION_NOT_VALID_FOR_TYPE	2045
MQRC_OPTIONS_ERROR	2046
MQRC_PERSISTENCE_ERROR	2047
MQRC_PERSISTENT_NOT_ALLOWED	2048
MQRC_PRIORITY_EXCEEDS_MAXIMUM	2049
MQRC_PRIORITY_ERROR	2050
MQRC_PUT_INHIBITED	2051
MQRC_Q_DELETED	2052
MQRC_Q_FULL	2053
MQRC_Q_NOT_EMPTY	2055
MQRC_Q_SPACE_NOT_AVAILABLE	2056
MQRC_Q_TYPE_ERROR	2057
MQRC_Q_MGR_NAME_ERROR	2058
MQRC_Q_MGR_NOT_AVAILABLE	2059
MQRC_REPORT_OPTIONS_ERROR	2061
MQRC_SECOND_MARK_NOT_ALLOWED	2062
MQRC_SECURITY_ERROR	2063
MQRC_SELECTOR_COUNT_ERROR	2065
MQRC_SELECTOR_LIMIT_EXCEEDED	2066
MQRC_SELECTOR_ERROR	2067
MQRC_SELECTOR_NOT_FOR_TYPE	2068
MQRC_SIGNAL_OUTSTANDING	2069
MQRC_SIGNAL_REQUEST_ACCEPTED	2070
MQRC_STORAGE_NOT_AVAILABLE	2071
MQRC_SYNCPOINT_NOT_AVAILABLE	2072
MQRC_TRIGGER_CONTROL_ERROR	2075
MQRC_TRIGGER_DEPTH_ERROR	2076
MQRC_TRIGGER_MSG_PRIORITY_ERR	2077
MQRC_TRIGGER_TYPE_ERROR	2078
MQRC_TRUNCATED_MSG_ACCEPTED	2079
MQRC_TRUNCATED_MSG_FAILED	2080
MQRC_UNKNOWN_ALIAS_BASE_Q	2082
MQRC_UNKNOWN_OBJECT_NAME	2085
MQRC_UNKNOWN_OBJECT_Q_MGR	2086
MQRC_UNKNOWN_REMOTE_Q_MGR	2087
MQRC_WAIT_INTERVAL_ERROR	2090
MQRC_XMIT_Q_TYPE_ERROR	2091
MQRC_XMIT_Q_USAGE_ERROR	2092
MQRC_NOT_OPEN_FOR_PASS_ALL	2093
MQRC_NOT_OPEN_FOR_PASS_IDENT	2094
MQRC_NOT_OPEN_FOR_SET_ALL	2095
MQRC_NOT_OPEN_FOR_SET_IDENT	2096
MQRC_CONTEXT_HANDLE_ERROR	2097
MQRC_CONTEXT_NOT_AVAILABLE	2098
MQRC_SIGNAL1_ERROR	2099
MQRC_OBJECT_ALREADY_EXISTS	2100
MQRC_OBJECT_DAMAGED	2101
MQRC_RESOURCE_PROBLEM	2102
MQRC_ANOTHER_Q_MGR_CONNECTED	2103
MQRC_UNKNOWN_REPORT_OPTION	2104
MQRC_STORAGE_CLASS_ERROR	2105
MQRC_COD_NOT_VALID_FOR_XCF_Q	2106
MQRC_SUPPRESSED_BY_EXIT	2109
MQRC_FORMAT_ERROR	2110
MQRC_SOURCE_CCSID_ERROR	2111
MQRC_SOURCE_INTEGER_ENC_ERROR	2112
MQRC_SOURCE_DECIMAL_ENC_ERROR	2113
MQRC_SOURCE_FLOAT_ENC_ERROR	2114
MQRC_TARGET_CCSID_ERROR	2115
MQRC_TARGET_INTEGER_ENC_ERROR	2116
MQRC_TARGET_DECIMAL_ENC_ERROR	2117
MQRC_TARGET_FLOAT_ENC_ERROR	2118
MQRC_NOT_CONVERTED	2119
MQRC_CONVERTED_MSG_TOO_BIG	2120
MQRC_TRUNCATED	2120
MQRC_NO_EXTERNAL_PARTICIPANTS	2121
MQRC_PARTICIPANT_NOT_AVAILABLE	2122
MQRC_OUTCOME_MIXED	2123
MQRC_OUTCOME_PENDING	2124
MQRC_BRIDGE_STARTED	2125
MQRC_BRIDGE_STOPPED	2126
MQRC_ADAPTER_STORAGE_SHORTAGE	2127
MQRC_UOW_IN_PROGRESS	2128
MQRC_ADAPTER_CONN_LOAD_ERROR	2129
MQRC_ADAPTER_SERV_LOAD_ERROR	2130
MQRC_ADAPTER_DEFS_ERROR	2131
MQRC_ADAPTER_DEFS_LOAD_ERROR	2132
MQRC_ADAPTER_CONV_LOAD_ERROR	2133
MQRC_BO_ERROR	2134
MQRC_DH_ERROR	2135
MQRC_MULTIPLE_REASONS	2136
MQRC_OPEN_FAILED	2137
MQRC_ADAPTER_DISC_LOAD_ERROR	2138
MQRC_CNO_ERROR	2139
MQRC_CICS_WAIT_FAILED	2140
MQRC_DLH_ERROR	2141
MQRC_HEADER_ERROR	2142
MQRC_SOURCE_LENGTH_ERROR	2143
MQRC_TARGET_LENGTH_ERROR	2144
MQRC_SOURCE_BUFFER_ERROR	2145
MQRC_TARGET_BUFFER_ERROR	2146
MQRC_IIH_ERROR	2148
MQRC_PCF_ERROR	2149
MQRC_DBCS_ERROR	2150
MQRC_OBJECT_NAME_ERROR	2152
MQRC_OBJECT_Q_MGR_NAME_ERROR	2153
MQRC_RECS_PRESENT_ERROR	2154
MQRC_OBJECT_RECORDS_ERROR	2155
MQRC_RESPONSE_RECORDS_ERROR	2156
MQRC_ASID_MISMATCH	2157
MQRC_PMO_RECORD_FLAGS_ERROR	2158
MQRC_PUT_MSG_RECORDS_ERROR	2159
MQRC_CONN_ID_IN_USE	2160
MQRC_Q_MGR_QUIESCING	2161
MQRC_Q_MGR_STOPPING	2162
MQRC_DUPLICATE_RECOV_COORD	2163
MQRC_PMO_ERROR	2173
MQRC_API_EXIT_NOT_FOUND	2182
MQRC_API_EXIT_LOAD_ERROR	2183
MQRC_REMOTE_Q_NAME_ERROR	2184
MQRC_INCONSISTENT_PERSISTENCE	2185
MQRC_GMO_ERROR	2186
MQRC_CICS_BRIDGE_RESTRICTION	2187
MQRC_STOPPED_BY_CLUSTER_EXIT	2188
MQRC_CLUSTER_RESOLUTION_ERROR	2189
MQRC_CONVERTED_STRING_TOO_BIG	2190
MQRC_TMC_ERROR	2191
MQRC_PAGESET_FULL	2192
MQRC_STORAGE_MEDIUM_FULL	2192
MQRC_PAGESET_ERROR	2193
MQRC_NAME_NOT_VALID_FOR_TYPE	2194
MQRC_UNEXPECTED_ERROR	2195
MQRC_UNKNOWN_XMIT_Q	2196
MQRC_UNKNOWN_DEF_XMIT_Q	2197
MQRC_DEF_XMIT_Q_TYPE_ERROR	2198
MQRC_DEF_XMIT_Q_USAGE_ERROR	2199
MQRC_NAME_IN_USE	2201
MQRC_CONNECTION_QUIESCING	2202
MQRC_CONNECTION_STOPPING	2203
MQRC_ADAPTER_NOT_AVAILABLE	2204
MQRC_MSG_ID_ERROR	2206
MQRC_CORREL_ID_ERROR	2207
MQRC_FILE_SYSTEM_ERROR	2208
MQRC_NO_MSG_LOCKED	2209
MQRC_FILE_NOT_AUDITED	2216
MQRC_CONNECTION_NOT_AUTHORIZED	2217
MQRC_MSG_TOO_BIG_FOR_CHANNEL	2218
MQRC_CALL_IN_PROGRESS	2219
MQRC_RMH_ERROR	2220
MQRC_Q_MGR_ACTIVE	2222
MQRC_Q_MGR_NOT_ACTIVE	2223
MQRC_Q_DEPTH_HIGH	2224
MQRC_Q_DEPTH_LOW	2225
MQRC_Q_SERVICE_INTERVAL_HIGH	2226
MQRC_Q_SERVICE_INTERVAL_OK	2227
MQRC_UNIT_OF_WORK_NOT_STARTED	2232
MQRC_CHANNEL_AUTO_DEF_OK	2233
MQRC_CHANNEL_AUTO_DEF_ERROR	2234
MQRC_CFH_ERROR	2235
MQRC_CFIL_ERROR	2236
MQRC_CFIN_ERROR	2237
MQRC_CFSL_ERROR	2238
MQRC_CFST_ERROR	2239
MQRC_INCOMPLETE_GROUP	2241
MQRC_INCOMPLETE_MSG	2242
MQRC_INCONSISTENT_CCSIDS	2243
MQRC_INCONSISTENT_ENCODINGS	2244
MQRC_INCONSISTENT_UOW	2245
MQRC_INVALID_MSG_UNDER_CURSOR	2246
MQRC_MATCH_OPTIONS_ERROR	2247
MQRC_MDE_ERROR	2248
MQRC_MSG_FLAGS_ERROR	2249
MQRC_MSG_SEQ_NUMBER_ERROR	2250
MQRC_OFFSET_ERROR	2251
MQRC_ORIGINAL_LENGTH_ERROR	2252
MQRC_SEGMENT_LENGTH_ZERO	2253
MQRC_UOW_NOT_AVAILABLE	2255
MQRC_WRONG_GMO_VERSION	2256
MQRC_WRONG_MD_VERSION	2257
MQRC_GROUP_ID_ERROR	2258
MQRC_INCONSISTENT_BROWSE	2259
MQRC_XQH_ERROR	2260
MQRC_SRC_ENV_ERROR	2261
MQRC_SRC_NAME_ERROR	2262
MQRC_DEST_ENV_ERROR	2263
MQRC_DEST_NAME_ERROR	2264
MQRC_TM_ERROR	2265
MQRC_CLUSTER_EXIT_ERROR	2266
MQRC_CLUSTER_EXIT_LOAD_ERROR	2267
MQRC_CLUSTER_PUT_INHIBITED	2268
MQRC_CLUSTER_RESOURCE_ERROR	2269
MQRC_NO_DESTINATIONS_AVAILABLE	2270
MQRC_CONN_TAG_IN_USE	2271
MQRC_PARTIALLY_CONVERTED	2272
MQRC_CONNECTION_ERROR	2273
MQRC_OPTION_ENVIRONMENT_ERROR	2274
MQRC_CD_ERROR	2277
MQRC_CLIENT_CONN_ERROR	2278
MQRC_CHANNEL_STOPPED_BY_USER	2279
MQRC_HCONFIG_ERROR	2280
MQRC_FUNCTION_ERROR	2281
MQRC_CHANNEL_STARTED	2282
MQRC_CHANNEL_STOPPED	2283
MQRC_CHANNEL_CONV_ERROR	2284
MQRC_SERVICE_NOT_AVAILABLE	2285
MQRC_INITIALIZATION_FAILED	2286
MQRC_TERMINATION_FAILED	2287
MQRC_UNKNOWN_Q_NAME	2288
MQRC_SERVICE_ERROR	2289
MQRC_Q_ALREADY_EXISTS	2290
MQRC_USER_ID_NOT_AVAILABLE	2291
MQRC_UNKNOWN_ENTITY	2292
MQRC_UNKNOWN_AUTH_ENTITY	2293
MQRC_UNKNOWN_REF_OBJECT	2294
MQRC_CHANNEL_ACTIVATED	2295
MQRC_CHANNEL_NOT_ACTIVATED	2296
MQRC_UOW_CANCELED	2297
MQRC_FUNCTION_NOT_SUPPORTED	2298
MQRC_SELECTOR_TYPE_ERROR	2299
MQRC_COMMAND_TYPE_ERROR	2300
MQRC_MULTIPLE_INSTANCE_ERROR	2301
MQRC_SYSTEM_ITEM_NOT_ALTERABLE	2302
MQRC_BAG_CONVERSION_ERROR	2303
MQRC_SELECTOR_OUT_OF_RANGE	2304
MQRC_SELECTOR_NOT_UNIQUE	2305
MQRC_INDEX_NOT_PRESENT	2306
MQRC_STRING_ERROR	2307
MQRC_ENCODING_NOT_SUPPORTED	2308
MQRC_SELECTOR_NOT_PRESENT	2309
MQRC_OUT_SELECTOR_ERROR	2310
MQRC_STRING_TRUNCATED	2311
MQRC_SELECTOR_WRONG_TYPE	2312
MQRC_INCONSISTENT_ITEM_TYPE	2313
MQRC_INDEX_ERROR	2314
MQRC_SYSTEM_BAG_NOT_ALTERABLE	2315
MQRC_ITEM_COUNT_ERROR	2316
MQRC_FORMAT_NOT_SUPPORTED	2317
MQRC_SELECTOR_NOT_SUPPORTED	2318
MQRC_ITEM_VALUE_ERROR	2319
MQRC_HBAG_ERROR	2320
MQRC_PARAMETER_MISSING	2321
MQRC_CMD_SERVER_NOT_AVAILABLE	2322
MQRC_STRING_LENGTH_ERROR	2323
MQRC_INQUIRY_COMMAND_ERROR	2324
MQRC_NESTED_BAG_NOT_SUPPORTED	2325
MQRC_BAG_WRONG_TYPE	2326
MQRC_ITEM_TYPE_ERROR	2327
MQRC_SYSTEM_BAG_NOT_DELETABLE	2328
MQRC_SYSTEM_ITEM_NOT_DELETABLE	2329
MQRC_CODED_CHAR_SET_ID_ERROR	2330
MQRC_MSG_TOKEN_ERROR	2331
MQRC_MISSING_WIH	2332
MQRC_WIH_ERROR	2333
MQRC_RFH_ERROR	2334
MQRC_RFH_STRING_ERROR	2335
MQRC_RFH_COMMAND_ERROR	2336
MQRC_RFH_PARM_ERROR	2337
MQRC_RFH_DUPLICATE_PARM	2338
MQRC_RFH_PARM_MISSING	2339
MQRC_CHAR_CONVERSION_ERROR	2340
MQRC_UCS2_CONVERSION_ERROR	2341
MQRC_DB2_NOT_AVAILABLE	2342
MQRC_OBJECT_NOT_UNIQUE	2343
MQRC_CONN_TAG_NOT_RELEASED	2344
MQRC_CF_NOT_AVAILABLE	2345
MQRC_CF_STRUC_IN_USE	2346
MQRC_CF_STRUC_LIST_HDR_IN_USE	2347
MQRC_CF_STRUC_AUTH_FAILED	2348
MQRC_CF_STRUC_ERROR	2349
MQRC_CONN_TAG_NOT_USABLE	2350
MQRC_GLOBAL_UOW_CONFLICT	2351
MQRC_LOCAL_UOW_CONFLICT	2352
MQRC_HANDLE_IN_USE_FOR_UOW	2353
MQRC_UOW_ENLISTMENT_ERROR	2354
MQRC_UOW_MIX_NOT_SUPPORTED	2355
MQRC_WXP_ERROR	2356
MQRC_CURRENT_RECORD_ERROR	2357
MQRC_NEXT_OFFSET_ERROR	2358
MQRC_NO_RECORD_AVAILABLE	2359
MQRC_OBJECT_LEVEL_INCOMPATIBLE	2360
MQRC_NEXT_RECORD_ERROR	2361
MQRC_SOURCE_CCSID_ERROR	2111
MQRC_SOURCE_INTEGER_ENC_ERROR	2112
MQRC_SOURCE_DECIMAL_ENC_ERROR	2113
MQRC_SOURCE_FLOAT_ENC_ERROR	2114
MQRC_TARGET_CCSID_ERROR	2115
MQRC_TARGET_INTEGER_ENC_ERROR	2116
MQRC_TARGET_DECIMAL_ENC_ERROR	2117
MQRC_TARGET_FLOAT_ENC_ERROR	2118
MQRC_NOT_CONVERTED	2119
MQRC_CONVERTED_MSG_TOO_BIG	2120
MQRC_TRUNCATED	2120
MQRC_NO_EXTERNAL_PARTICIPANTS	2121
MQRC_PARTICIPANT_NOT_AVAILABLE	2122
MQRC_OUTCOME_MIXED	2123
MQRC_OUTCOME_PENDING	2124
MQRC_BRIDGE_STARTED	2125
MQRC_BRIDGE_STOPPED	2126
MQRC_ADAPTER_STORAGE_SHORTAGE	2127
MQRC_UOW_IN_PROGRESS	2128
MQRC_ADAPTER_CONN_LOAD_ERROR	2129
MQRC_ADAPTER_SERV_LOAD_ERROR	2130
MQRC_ADAPTER_DEFS_ERROR	2131
MQRC_ADAPTER_DEFS_LOAD_ERROR	2132
MQRC_ADAPTER_CONV_LOAD_ERROR	2133
MQRC_BO_ERROR	2134
MQRC_DH_ERROR	2135
MQRC_MULTIPLE_REASONS	2136
MQRC_OPEN_FAILED	2137
MQRC_ADAPTER_DISC_LOAD_ERROR	2138
MQRC_CNO_ERROR	2139
MQRC_CICS_WAIT_FAILED	2140
MQRC_DLH_ERROR	2141
MQRC_HEADER_ERROR	2142
MQRC_SOURCE_LENGTH_ERROR	2143
MQRC_TARGET_LENGTH_ERROR	2144
MQRC_SOURCE_BUFFER_ERROR	2145
MQRC_TARGET_BUFFER_ERROR	2146
MQRC_IIH_ERROR	2148
MQRC_PCF_ERROR	2149
MQRC_DBCS_ERROR	2150
MQRC_OBJECT_NAME_ERROR	2152
MQRC_OBJECT_Q_MGR_NAME_ERROR	2153
MQRC_RECS_PRESENT_ERROR	2154
MQRC_OBJECT_RECORDS_ERROR	2155
MQRC_RESPONSE_RECORDS_ERROR	2156
MQRC_ASID_MISMATCH	2157
MQRC_PMO_RECORD_FLAGS_ERROR	2158
MQRC_PUT_MSG_RECORDS_ERROR	2159
MQRC_CONN_ID_IN_USE	2160
MQRC_Q_MGR_QUIESCING	2161
MQRC_Q_MGR_STOPPING	2162
MQRC_DUPLICATE_RECOV_COORD	2163
MQRC_PMO_ERROR	2173
MQRC_API_EXIT_NOT_FOUND	2182
MQRC_API_EXIT_LOAD_ERROR	2183
MQRC_REMOTE_Q_NAME_ERROR	2184
MQRC_INCONSISTENT_PERSISTENCE	2185
MQRC_GMO_ERROR	2186
MQRC_CICS_BRIDGE_RESTRICTION	2187
MQRC_STOPPED_BY_CLUSTER_EXIT	2188
MQRC_CLUSTER_RESOLUTION_ERROR	2189
MQRC_CONVERTED_STRING_TOO_BIG	2190
MQRC_TMC_ERROR	2191
MQRC_PAGESET_FULL	2192
MQRC_STORAGE_MEDIUM_FULL	2192
MQRC_PAGESET_ERROR	2193
MQRC_NAME_NOT_VALID_FOR_TYPE	2194
MQRC_UNEXPECTED_ERROR	2195
MQRC_UNKNOWN_XMIT_Q	2196
MQRC_UNKNOWN_DEF_XMIT_Q	2197
MQRC_DEF_XMIT_Q_TYPE_ERROR	2198
MQRC_DEF_XMIT_Q_USAGE_ERROR	2199
MQRC_NAME_IN_USE	2201
MQRC_CONNECTION_QUIESCING	2202
MQRC_CONNECTION_STOPPING	2203
MQRC_ADAPTER_NOT_AVAILABLE	2204
MQRC_MSG_ID_ERROR	2206
MQRC_CORREL_ID_ERROR	2207
MQRC_FILE_SYSTEM_ERROR	2208
MQRC_NO_MSG_LOCKED	2209
MQRC_FILE_NOT_AUDITED	2216
MQRC_CONNECTION_NOT_AUTHORIZED	2217
MQRC_MSG_TOO_BIG_FOR_CHANNEL	2218
MQRC_CALL_IN_PROGRESS	2219
MQRC_RMH_ERROR	2220
MQRC_Q_MGR_ACTIVE	2222
MQRC_Q_MGR_NOT_ACTIVE	2223
MQRC_Q_DEPTH_HIGH	2224
MQRC_Q_DEPTH_LOW	2225
MQRC_Q_SERVICE_INTERVAL_HIGH	2226
MQRC_Q_SERVICE_INTERVAL_OK	2227
MQRC_UNIT_OF_WORK_NOT_STARTED	2232
MQRC_CHANNEL_AUTO_DEF_OK	2233
MQRC_CHANNEL_AUTO_DEF_ERROR	2234
MQRC_CFH_ERROR	2235
MQRC_CFIL_ERROR	2236
MQRC_CFIN_ERROR	2237
MQRC_CFSL_ERROR	2238
MQRC_CFST_ERROR	2239
MQRC_INCOMPLETE_GROUP	2241
MQRC_INCOMPLETE_MSG	2242
MQRC_INCONSISTENT_CCSIDS	2243
MQRC_INCONSISTENT_ENCODINGS	2244
MQRC_INCONSISTENT_UOW	2245
MQRC_INVALID_MSG_UNDER_CURSOR	2246
MQRC_MATCH_OPTIONS_ERROR	2247
MQRC_MDE_ERROR	2248
MQRC_MSG_FLAGS_ERROR	2249
MQRC_MSG_SEQ_NUMBER_ERROR	2250
MQRC_OFFSET_ERROR	2251
MQRC_ORIGINAL_LENGTH_ERROR	2252
MQRC_SEGMENT_LENGTH_ZERO	2253
MQRC_UOW_NOT_AVAILABLE	2255
MQRC_WRONG_GMO_VERSION	2256
MQRC_WRONG_MD_VERSION	2257
MQRC_GROUP_ID_ERROR	2258
MQRC_INCONSISTENT_BROWSE	2259
MQRC_XQH_ERROR	2260
MQRC_SRC_ENV_ERROR	2261
MQRC_SRC_NAME_ERROR	2262
MQRC_DEST_ENV_ERROR	2263
MQRC_DEST_NAME_ERROR	2264
MQRC_TM_ERROR	2265
MQRC_CLUSTER_EXIT_ERROR	2266
MQRC_CLUSTER_EXIT_LOAD_ERROR	2267
MQRC_CLUSTER_PUT_INHIBITED	2268
MQRC_CLUSTER_RESOURCE_ERROR	2269
MQRC_NO_DESTINATIONS_AVAILABLE	2270
MQRC_CONN_TAG_IN_USE	2271
MQRC_PARTIALLY_CONVERTED	2272
MQRC_CONNECTION_ERROR	2273
MQRC_OPTION_ENVIRONMENT_ERROR	2274
MQRC_CD_ERROR	2277
MQRC_CLIENT_CONN_ERROR	2278
MQRC_CHANNEL_STOPPED_BY_USER	2279
MQRC_HCONFIG_ERROR	2280
MQRC_FUNCTION_ERROR	2281
MQRC_CHANNEL_STARTED	2282
MQRC_CHANNEL_STOPPED	2283
MQRC_CHANNEL_CONV_ERROR	2284
MQRC_SERVICE_NOT_AVAILABLE	2285
MQRC_INITIALIZATION_FAILED	2286
MQRC_TERMINATION_FAILED	2287
MQRC_UNKNOWN_Q_NAME	2288
MQRC_SERVICE_ERROR	2289
MQRC_Q_ALREADY_EXISTS	2290
MQRC_USER_ID_NOT_AVAILABLE	2291
MQRC_UNKNOWN_ENTITY	2292
MQRC_UNKNOWN_AUTH_ENTITY	2293
MQRC_UNKNOWN_REF_OBJECT	2294
MQRC_CHANNEL_ACTIVATED	2295
MQRC_CHANNEL_NOT_ACTIVATED	2296
MQRC_UOW_CANCELED	2297
MQRC_FUNCTION_NOT_SUPPORTED	2298
MQRC_SELECTOR_TYPE_ERROR	2299
MQRC_COMMAND_TYPE_ERROR	2300
MQRC_MULTIPLE_INSTANCE_ERROR	2301
MQRC_SYSTEM_ITEM_NOT_ALTERABLE	2302
MQRC_BAG_CONVERSION_ERROR	2303
MQRC_SELECTOR_OUT_OF_RANGE	2304
MQRC_SELECTOR_NOT_UNIQUE	2305
MQRC_INDEX_NOT_PRESENT	2306
MQRC_STRING_ERROR	2307
MQRC_ENCODING_NOT_SUPPORTED	2308
MQRC_SELECTOR_NOT_PRESENT	2309
MQRC_OUT_SELECTOR_ERROR	2310
MQRC_STRING_TRUNCATED	2311
MQRC_SELECTOR_WRONG_TYPE	2312
MQRC_INCONSISTENT_ITEM_TYPE	2313
MQRC_INDEX_ERROR	2314
MQRC_SYSTEM_BAG_NOT_ALTERABLE	2315
MQRC_ITEM_COUNT_ERROR	2316
MQRC_FORMAT_NOT_SUPPORTED	2317
MQRC_SELECTOR_NOT_SUPPORTED	2318
MQRC_ITEM_VALUE_ERROR	2319
MQRC_HBAG_ERROR	2320
MQRC_PARAMETER_MISSING	2321
MQRC_CMD_SERVER_NOT_AVAILABLE	2322
MQRC_STRING_LENGTH_ERROR	2323
MQRC_INQUIRY_COMMAND_ERROR	2324
MQRC_NESTED_BAG_NOT_SUPPORTED	2325
MQRC_BAG_WRONG_TYPE	2326
MQRC_ITEM_TYPE_ERROR	2327
MQRC_SYSTEM_BAG_NOT_DELETABLE	2328
MQRC_SYSTEM_ITEM_NOT_DELETABLE	2329
MQRC_CODED_CHAR_SET_ID_ERROR	2330
MQRC_MSG_TOKEN_ERROR	2331
MQRC_MISSING_WIH	2332
MQRC_WIH_ERROR	2333
MQRC_RFH_ERROR	2334
MQRC_RFH_STRING_ERROR	2335
MQRC_RFH_COMMAND_ERROR	2336
MQRC_RFH_PARM_ERROR	2337
MQRC_RFH_DUPLICATE_PARM	2338
MQRC_RFH_PARM_MISSING	2339
MQRC_CHAR_CONVERSION_ERROR	2340
MQRC_UCS2_CONVERSION_ERROR	2341
MQRC_DB2_NOT_AVAILABLE	2342
MQRC_OBJECT_NOT_UNIQUE	2343
MQRC_CONN_TAG_NOT_RELEASED	2344
MQRC_CF_NOT_AVAILABLE	2345
MQRC_CF_STRUC_IN_USE	2346
MQRC_CF_STRUC_LIST_HDR_IN_USE	2347
MQRC_CF_STRUC_AUTH_FAILED	2348
MQRC_CF_STRUC_ERROR	2349
MQRC_CONN_TAG_NOT_USABLE	2350
MQRC_GLOBAL_UOW_CONFLICT	2351
MQRC_LOCAL_UOW_CONFLICT	2352
MQRC_HANDLE_IN_USE_FOR_UOW	2353
MQRC_UOW_ENLISTMENT_ERROR	2354
MQRC_UOW_MIX_NOT_SUPPORTED	2355
MQRC_WXP_ERROR	2356
MQRC_CURRENT_RECORD_ERROR	2357
MQRC_NEXT_OFFSET_ERROR	2358
MQRC_NO_RECORD_AVAILABLE	2359
MQRC_OBJECT_LEVEL_INCOMPATIBLE	2360
MQRC_NEXT_RECORD_ERROR	2361