/*****************************************************************************/
/*                                                                           */
/* (c) Copyright IBM Corp. 2003  All rights reserved.                        */
/*                                                                           */
/* This sample program is owned by International Business Machines           */
/* Corporation or one of its subsidiaries ("IBM") and is copyrighted         */
/* and licensed, not sold.                                                   */
/*                                                                           */
/* You may copy, modify, and distribute this sample program in any           */
/* form without payment to IBM,  for any purpose including developing,       */
/* using, marketing or distributing programs that include or are             */
/* derivative works of the sample program.                                   */
/*                                                                           */
/* The sample program is provided to you on an "AS IS" basis, without        */
/* warranty of any kind.  IBM HEREBY  EXPRESSLY DISCLAIMS ALL WARRANTIES,    */
/* EITHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED     */
/* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.       */
/* Some jurisdictions do not allow for the exclusion or limitation of        */
/* implied warranties, so the above limitations or exclusions may not        */
/* apply to you.  IBM shall not be liable for any damages you suffer as      */
/* a result of using, modifying or distributing the sample program or        */
/* its derivatives.                                                          */
/*                                                                           */
/*****************************************************************************/
/*                                                                           */
/* Program name: qstatus                                                     */
/*                                                                           */
/* Description:  This sample demonstates how to retrieve information about   */
/*               processes that have a queue open.                           */
/*                                                                           */
/* Function:     This sample uses the MQAI interface to send a               */
/*               MQCMD_INQUIRE_Q_STATUS with a status type of                */  
/*               MQIACF_Q_HANDLE to the command server.                      */
/*               It retrieves the reply from the command server in a         */
/*               temporary dynamic queue and parses out the queue status     */
/*               attributes and presents them to standard out.               */
/*               This sample is based on amqsailq.c                          */
/*                                                                           */
/* Prereqs:      This sample program requires WebSphere MQ 5.3               */
/*                                                                           */
/*                                                                           */
/* Build:        This program has been tested with WebSphere MQ 5.3.0.1      */
/*               on Windows/2000 using Visual C++ 6.0 compiler.              */
/*               Build using the command:                                    */
/*                                                                           */
/*               cl qstatus.c mqm.lib                                        */
/*                                                                           */
/* Execute:      Run this program with the command:                          */
/*                 qstatus queuename <queuemgrname>                          */
/*                 where queuename is the name of a local queue or a         */
/*                 a name containing wildcard characters.                    */
/*                                                                           */
/*****************************************************************************/



/******************************************************************************/
/* Includes                                                                   */
/******************************************************************************/
#include <stdio.h>
#include <string.h>           
#include <stdlib.h>          
#include <ctype.h>              

#include <cmqc.h>                          /* MQI                             */
#include <cmqcfc.h>                        /* PCF                             */
#include <cmqbc.h>                         /* MQAI                            */

#define  WAIT_TIME    5000                 /* wait time for mqexecute         */

/******************************************************************************/
/* Function prototypes                                                        */
/******************************************************************************/
void CheckCallResult(MQCHAR *, MQLONG , MQLONG);

/******************************************************************************/
/* Function: main                                                             */
/******************************************************************************/
int main(int argc, char *argv[])                 
{
   /***************************************************************************/
   /* MQAI variables                                                          */
   /***************************************************************************/
   MQHCONN hConn;                          /* handle to MQ connection         */
   MQCHAR qmName[MQ_Q_MGR_NAME_LENGTH+1]=""; /* default QMgr name             */
   MQCHAR qName[MQ_Q_NAME_LENGTH+1]="";    /* queue name to query             */
   MQLONG reason;                          /* reason code                     */
   MQLONG connReason;                      /* MQCONN reason code              */
   MQLONG compCode;                        /* completion code                 */
   MQHBAG adminBag = MQHB_UNUSABLE_HBAG;   /* admin bag for mqExecute         */
   MQHBAG responseBag = MQHB_UNUSABLE_HBAG; /* response bag for mqExecute      */
   MQHBAG optionsBag = MQHB_UNUSABLE_HBAG; /* options bag for mqExecute       */
   MQHBAG qAttrsBag;                       /* bag containing q attributes     */
   MQHBAG errorBag;                        /* bag containing cmd server error */
   MQLONG mqExecuteCC;                     /* mqExecute completion code       */
   MQLONG mqExecuteRC;                     /* mqExecute reason code           */
   MQLONG strAttrLength;                   /* Actual length of q name         */
   MQLONG intAttr;                         /* integer attribute returned      */
   MQLONG i;                               /* loop counter                    */
   MQLONG numberOfBags;                    /* number of bags in response bag  */
   MQCHAR strAttr[256];                    /* string attribute returned       */


   if (argc < 2)
   {
      printf("Syntax: %s queuename <queue manager name>\n",argv[0]);
      printf("\tqueuename may contain wildcard characters.\n");
      exit(-1);
   }

   strncpy(qName, argv[1], MQ_Q_NAME_LENGTH);
   printf("\nDisplay current status of queue %s\n\n", qName);

   /***************************************************************************/
   /* Connect to the queue manager                                            */
   /***************************************************************************/
   if (argc > 2)
      strncpy(qmName, argv[2], (size_t)MQ_Q_MGR_NAME_LENGTH);
   MQCONN(qmName, &hConn, &compCode, &connReason);    

   /***************************************************************************/
   /* Report the reason and stop if the connection failed.                    */
   /***************************************************************************/
   if (compCode == MQCC_FAILED)
   {
      CheckCallResult("Queue Manager connection", compCode, connReason);
      exit( (int)connReason);
   }

   /***************************************************************************/
   /* Create an admin bag for the mqExecute call                              */
   /***************************************************************************/
   mqCreateBag(MQCBO_ADMIN_BAG, &adminBag, &compCode, &reason);
   CheckCallResult("Create admin bag", compCode, reason);

   /***************************************************************************/
   /* Create a response bag for the mqExecute call                            */
   /***************************************************************************/
   if (compCode == MQCC_OK)
   {
      mqCreateBag(MQCBO_ADMIN_BAG, &responseBag, &compCode, &reason);
      CheckCallResult("Create response bag", compCode, reason);
   }

   /***************************************************************************/
   /* Create an options bag to set the timeout value of the mqexecute call    */
   /***************************************************************************/
   if (compCode == MQCC_OK)
   {
      mqCreateBag(MQCBO_USER_BAG, &optionsBag, &compCode, &reason);
      CheckCallResult("Create options bag", compCode, reason);
      if (compCode == MQCC_OK && reason == MQRC_NONE)
      {
         mqAddInteger(optionsBag, MQIACF_WAIT_INTERVAL, WAIT_TIME, &compCode, &reason);
      }

      /********************************************************/
      /* If generating the options bag fails, just use the    */
      /* default time of 30 seconds by setting options bag    */
      /* to MQHB_NONE                                         */
      /********************************************************/
      if (compCode != MQCC_OK)
      {
         optionsBag = MQHB_NONE;
         compCode   = MQCC_OK;
         reason     = MQRC_NONE;
      }
   }

   /***************************************************************************/
   /* Put the queue name into the admin bag                                   */
   /***************************************************************************/
   if (compCode == MQCC_OK)
   {
      mqAddString(adminBag, MQCA_Q_NAME, MQBL_NULL_TERMINATED, qName, &compCode, &reason);
      CheckCallResult("Add q name", compCode, reason);
   }

   /***************************************************************************/
   /* Put the status type into the admin bag                                  */
   /* Type must be HANDLE to get open status detail                           */
   /***************************************************************************/
   if (compCode == MQCC_OK)
   {
      mqAddInteger(adminBag, MQIACF_Q_STATUS_TYPE, MQIACF_Q_HANDLE, &compCode, &reason);
      CheckCallResult("Add status type", compCode, reason);
   }

   /***************************************************************************/
   /* Indicate we want all attributes                                         */
   /***************************************************************************/
   if (compCode == MQCC_OK)
   {
      mqAddInteger(adminBag, MQIACF_Q_STATUS_ATTRS, MQIACF_ALL, &compCode, &reason);
      CheckCallResult("Add status attrs", compCode, reason);
   }

   /***************************************************************************/
   /* The mqExecute call creates the PCF structure required, sends it to      */
   /* the command server, and receives the reply from the command server into */
   /* the response bag. The attributes are contained in system bags that are  */
   /* embedded in the response bag, one set of attributes per bag.            */
   /***************************************************************************/
   if (compCode == MQCC_OK)
   {
      mqExecute(hConn,                /* MQ connection handle                 */
                MQCMD_INQUIRE_Q_STATUS,/* Command to be executed              */
                optionsBag,           /* No options bag                       */
                adminBag,             /* Handle to bag containing commands    */
                responseBag,          /* Handle to bag to receive the response*/
                MQHO_NONE,            /* Put msg on SYSTEM.ADMIN.COMMAND.QUEUE*/  
                MQHO_NONE,            /* Create a dynamic q for the response  */ 
                &compCode,            /* Completion code from the mqexecute   */ 
                &reason);             /* Reason code from mqexecute call      */
   }

   /***************************************************************************/
   /* Check the command server is started. If not exit.                       */
   /***************************************************************************/
   if (reason == MQRC_CMD_SERVER_NOT_AVAILABLE)
   {
      printf("Please start the command server: <strmqcsv QMgrName>\n");
      MQDISC(&hConn, &compCode, &reason);
      CheckCallResult("Disconnect from Queue Manager", compCode, reason);         
      exit(98);
   }

   /***************************************************************************/
   /* Check the result from mqExecute call. If successful find the current    */
   /* depths of all the local queues. If failed find the error.               */
   /***************************************************************************/
   if ( compCode == MQCC_OK )                      /* Successful mqExecute    */
   {
      /*************************************************************************/
      /* Count the number of system bags embedded in the response bag from the */
      /* mqExecute call. The attributes for each queue are in a separate bag.  */
      /*************************************************************************/
      mqCountItems(responseBag, MQHA_BAG_HANDLE, &numberOfBags, &compCode, &reason);
      CheckCallResult("Count number of bag handles", compCode, reason); 

      for ( i=0; i<numberOfBags; i++)
      { 
         /***********************************************************************/
         /* Get the next system bag handle out of the mqExecute response bag.   */
         /* This bag contains the queue attributes                              */
         /***********************************************************************/
         mqInquireBag(responseBag, MQHA_BAG_HANDLE, i, &qAttrsBag, &compCode, &reason);
         CheckCallResult("Get the result bag handle", compCode, reason);

         if (compCode == MQCC_OK && reason == MQRC_NONE)
         {
            /***********************************************************************/
            /* Get the queue name out of the queue attributes bag                  */
            /***********************************************************************/
            mqInquireString(qAttrsBag, MQCA_Q_NAME, 0, MQ_Q_NAME_LENGTH, strAttr,
                            &strAttrLength, NULL, &compCode, &reason);
            if (compCode == MQCC_OK && reason == MQRC_NONE)
            {
               mqTrim(MQ_Q_NAME_LENGTH, strAttr, strAttr, &compCode, &reason);
               printf("Queue name:           %s\n", strAttr);
            }

            /***********************************************************************/
            /* Get the process id out of the attributes bag                        */
            /***********************************************************************/
            mqInquireInteger(qAttrsBag, MQIACF_PROCESS_ID, MQIND_NONE, &intAttr,
                             &compCode, &reason);
            if (compCode == MQCC_OK && reason == MQRC_NONE)
            {
               printf("Process ID:           %04ld\n",intAttr);
            }

            /***********************************************************************/
            /* Get the thread id out of the attributes bag                         */
            /***********************************************************************/
            mqInquireInteger(qAttrsBag, MQIACF_THREAD_ID, MQIND_NONE, &intAttr,
                             &compCode, &reason);
            if (compCode == MQCC_OK && reason == MQRC_NONE)
            {
               printf("Thread ID:            %04ld\n",intAttr);
            }

            /***********************************************************************/
            /* Get the application type out of the attributes bag                  */
            /***********************************************************************/
            mqInquireInteger(qAttrsBag, MQIA_APPL_TYPE, MQIND_NONE, &intAttr,
                             &compCode, &reason);
            if (compCode == MQCC_OK && reason == MQRC_NONE)
            {
               printf("Application Type:     ");
               switch (intAttr)
               {
                  case MQAT_CICS:
                     printf("CICS\n");
                     break;
                  case MQAT_ZOS:
                     printf("ZOS\n");
                     break;
                  case MQAT_IMS:
                     printf("IMS\n");
                     break;
                  case MQAT_OS2:
                     printf("OS2\n");
                     break;
                  case MQAT_DOS:
                     printf("DOS\n");
                     break;
                  case MQAT_UNIX:
                     printf("UNIX\n");
                     break;
                  case MQAT_QMGR:
                     printf("QMGR\n");
                     break;
                  case MQAT_OS400:
                     printf("OS400\n");
                     break;
                  case MQAT_WINDOWS:
                     printf("WINDOWS\n");
                     break;
                  case MQAT_CICS_VSE:
                     printf("CICS VSE\n");
                     break;
                  case MQAT_WINDOWS_NT:
                     printf("WINDOWS/NT/2000/XP\n");
                     break;
                  case MQAT_VMS:
                     printf("VMS\n");
                     break;
                  case MQAT_NSK:
                     printf("NSK\n");
                     break;
                  case MQAT_VOS:
                     printf("VOS\n");
                     break;
                  case MQAT_IMS_BRIDGE:
                     printf("IMS_BRIDGE\n");
                     break;
                  case MQAT_XCF:
                     printf("XCF\n");
                     break;
                  case MQAT_CICS_BRIDGE:
                     printf("CICS BRIDGE\n");
                     break;
                  case MQAT_NOTES_AGENT:
                     printf("NOTES AGENT\n");
                     break;
                  case MQAT_USER:
                     printf("USER\n");
                     break;
                  case MQAT_BROKER:
                     printf("BROKER\n");
                     break;
                  case MQAT_JAVA:
                     printf("JAVA\n");
                     break;
                  case MQAT_DQM:
                     printf("DQM\n");
                     break;
                  case MQAT_CHANNEL_INITIATOR:
                     printf("CHANNEL INITIATOR\n");
                     break;
                  default:
                     printf("UNKNOWN\n");
               }
            }

            /***********************************************************************/
            /* Get the Open Share options out of the attributes bag                */
            /***********************************************************************/
            mqInquireInteger(qAttrsBag, MQIACF_OPEN_INPUT_TYPE, MQIND_NONE, &intAttr,
                             &compCode, &reason);
            if (compCode == MQCC_OK && reason == MQRC_NONE)
            {
               printf("Open for Input:       ");
               switch (intAttr)
               {
                  case MQQSO_NO:
                     printf("FALSE\n");
                     break;
                  case MQQSO_SHARED:
                     printf("SHARED\n");
                     break;
                  case MQQSO_EXCLUSIVE:
                     printf("EXCLUSIVE\n");
                     break;
               }
            }

            /***********************************************************************/
            /* Get the Open Output out of the attributes bag                       */
            /***********************************************************************/
            mqInquireInteger(qAttrsBag, MQIACF_OPEN_OUTPUT, MQIND_NONE, &intAttr,
                             &compCode, &reason);
            if (compCode == MQCC_OK && reason == MQRC_NONE)
            {
               printf("Open for Output:      ");
               if (intAttr)
                  printf("TRUE\n");
               else
                  printf("FALSE\n");
            }

            /***********************************************************************/
            /* Get the Open Set out of the attributes bag                          */
            /***********************************************************************/
            mqInquireInteger(qAttrsBag, MQIACF_OPEN_SET, MQIND_NONE, &intAttr,
                             &compCode, &reason);
            if (compCode == MQCC_OK && reason == MQRC_NONE)
            {
               printf("Open for Set:         ");
               if (intAttr)
                  printf("TRUE\n");
               else
                  printf("FALSE\n");
            }

            /***********************************************************************/
            /* Get the Open Inquire out of the attributes bag                      */
            /***********************************************************************/
            mqInquireInteger(qAttrsBag, MQIACF_OPEN_INQUIRE, MQIND_NONE, &intAttr,
                             &compCode, &reason);
            if (compCode == MQCC_OK && reason == MQRC_NONE)
            {
               printf("Open for Inquire:     ");
               if (intAttr)
                  printf("TRUE\n");
               else
                  printf("FALSE\n");
            }


            /***********************************************************************/
            /* Get the Open Browse out of the attributes bag                       */
            /***********************************************************************/
            mqInquireInteger(qAttrsBag, MQIACF_OPEN_BROWSE, MQIND_NONE, &intAttr,
                             &compCode, &reason);
            if (compCode == MQCC_OK && reason == MQRC_NONE)
            {
               printf("Open for Browse:      ");
               if (intAttr)
                  printf("TRUE\n");
               else
                  printf("FALSE\n");
            }

            /***********************************************************************/
            /* Get the USER ID out of the attributes bag                           */
            /***********************************************************************/
            *strAttr = '\0';
            mqInquireString(qAttrsBag, MQCACF_USER_IDENTIFIER, 0, sizeof(strAttr), 
                            strAttr, &strAttrLength, NULL, &compCode, &reason);
            if (compCode==0 && reason==0)
            {
               mqTrim(strAttrLength, strAttr, strAttr, &compCode, &reason);
               printf("User ID:              %s\n",strAttr);
            }

            /***********************************************************************/
            /* Get the Application Name out of the attributes bag                  */
            /***********************************************************************/
            *strAttr = '\0';
            mqInquireString(qAttrsBag, MQCACF_APPL_TAG, 0, sizeof(strAttr), 
                            strAttr, &strAttrLength, NULL, &compCode, &reason);
            if (compCode==0 && reason==0)
            {
               mqTrim(strAttrLength, strAttr, strAttr, &compCode, &reason);
               printf("Application:          %s\n",strAttr);
            }

            /***********************************************************************/
            /* Get the Channel Name out of the attributes bag                      */
            /***********************************************************************/
            *strAttr = '\0';
            mqInquireString(qAttrsBag, MQCACH_CHANNEL_NAME, 0, sizeof(strAttr), 
                            strAttr, &strAttrLength, NULL, &compCode, &reason);
            if (compCode==0 && reason==0)
            {
               mqTrim(strAttrLength, strAttr, strAttr, &compCode, &reason);
               printf("Channel Name:         %s\n",strAttr);
            }

            /***********************************************************************/
            /* Get the Connection Name out of the attributes bag                   */
            /***********************************************************************/
            *strAttr = '\0';
            mqInquireString(qAttrsBag, MQCACH_CONNECTION_NAME, 0, sizeof(strAttr), 
                            strAttr, &strAttrLength, NULL, &compCode, &reason);
            if (compCode==0 && reason==0)
            {
               mqTrim(strAttrLength, strAttr, strAttr, &compCode, &reason);
               printf("CconnectionName:      %s\n",strAttr);
            }

         }
         printf("\n");
      } 
   }

   else                                               /* Failed mqExecute     */
   { 
      /*************************************************************************/
      /* If the command fails get the system bag handle out of the mqexecute   */
      /* response bag.This bag contains the reason from the command server     */
      /* why the command failed.                                               */
      /*************************************************************************/
      switch (reason)
      {
         case MQRCCF_COMMAND_FAILED:

            mqInquireBag(responseBag, MQHA_BAG_HANDLE, 0, &errorBag, &compCode, &reason);
            CheckCallResult("Get the result bag handle", compCode, reason);

            /***********************************************************************/
            /* Get the completion code and reason code, returned by the command    */
            /* server, from the embedded error bag.                                */
            /***********************************************************************/
            mqInquireInteger(errorBag, MQIASY_COMP_CODE, MQIND_NONE, &mqExecuteCC, 
                             &compCode, &reason );
            CheckCallResult("Get the completion code from the result bag", compCode, reason); 
            mqInquireInteger(errorBag, MQIASY_REASON, MQIND_NONE, &mqExecuteRC,
                             &compCode, &reason);
            CheckCallResult("Get the reason code from the result bag", compCode, reason);
            if (mqExecuteRC == MQRCCF_Q_STATUS_NOT_FOUND)
            {
               printf("No processes have queue %s open.\n",qName);
            }
            else
            {
               printf("Error returned by the command server: Completion Code = %d : Reason = %d\n",
                      mqExecuteCC, mqExecuteRC);       
            }

            break;
         
         case MQRC_NO_MSG_AVAILABLE:

            printf("No results returned for queue %s. This queue may not exist.\n", qName);
            break;

         default:
            printf("Call to get queue status attributes failed: Completion Code = %d : Reason = %d\n",
                   compCode, reason);
      }

   }  

   /***************************************************************************/
   /* Delete the admin bag if successfully created.                           */
   /***************************************************************************/
   if (adminBag != MQHB_UNUSABLE_HBAG)
   {
      mqDeleteBag(&adminBag, &compCode, &reason);
      CheckCallResult("Delete the admin bag", compCode, reason);
   }

   /***************************************************************************/
   /* Delete the response bag if successfully created.                        */
   /***************************************************************************/
   if (responseBag != MQHB_UNUSABLE_HBAG)
   {
      mqDeleteBag(&responseBag, &compCode, &reason);
      CheckCallResult("Delete the response bag", compCode, reason);
   }

   /***************************************************************************/
   /* Disconnect from the queue manager if not already connected              */
   /***************************************************************************/
   if (connReason != MQRC_ALREADY_CONNECTED)
   {
      MQDISC(&hConn, &compCode, &reason);
      CheckCallResult("Disconnect from Queue Manager", compCode, reason);         
   }
   return MQCC_OK;                               
}


/******************************************************************************/
/*                                                                            */
/* Function: CheckCallResult                                                  */ 
/*                                                                            */
/******************************************************************************/
/*                                                                            */
/* Input Parameters:  Description of call                                     */
/*                    Completion code                                         */
/*                    Reason code                                             */
/*                                                                            */
/* Output Parameters: None                                                    */
/*                                                                            */
/* Logic: Display the description of the call, the completion code and the    */
/*        reason code if the completion code is not successful                */
/*                                                                            */
/******************************************************************************/
void  CheckCallResult(char *callText, MQLONG cc, MQLONG rc)
{
   if (cc != MQCC_OK)
      printf("%s failed: Completion Code = %d : Reason = %d\n", callText, cc, rc);

}