15.10 - Sample Application - Teradata Database

Teradata Database Application Programming Reference

prodname
Teradata Database
vrm_release
15.10
category
Programming Reference
featnum
B035-1090-151K

The following is a sample of a CLI program.

/**********************************************************************/
/* This is a sample PM/API application.                               */
/* 1) Prompts for a logon string                                      */
/* 2) Connects to a Teradata RDBMS and establishes a MONITOR session */
/* 3) Prompts for input parameter for MONITOR SESSION; PM/API command */
/* 4) Submits MONITOR SESSION;                                        */
/* 5) Retrieves the response, formats and prints the response parcels */
/* 6) Above 3 - 5 are repeated until Q is entered in #3.              */
/* 7) Disconnects.                                                     */
/**********************************************************************/
 
#include <stdio.h>       
#include <string.h>
#include <stdlib.h>
 
#include "samplepmpc.h"
 
// Global variables
struct  DBCAREA dbc;    /* see dbcarea.h for definition of structure */
 
char    cnta[4];
 
int     IndicatorMode; 
 
unsigned short TargetVersion = 6;
char           RespMode = 'R';
 
static int IndicFieldCount = 0;
static char CurrRequestText[32];
 
#define MON_SESS_REQ   1
 
// List of field names for Monitor Session Record 2
char *MonSesRec2fieldnamelist[]= {
    "HostId",
    "LogonProcId",
    "RunProcId",
    "SessionNo",
    "UserName",
    "UserAccount",
    "UserId",
    "LSN",
    "LogonTime",
    "LogonDate",
    "PartName",
    "Priority",
    "IFPState",
    "IFPCPUSec",
    "XactCount",
    "ReqCount",
    "ReqCacheHits",
    "AMPState",
    "AMPCPUSec",
    "AMPIO",
    "DeltaAMPSpool",
    "Blk1HostId",
    "Blk1SessNo",
    ""Blk1UserId",
    "Blk1LMode",
    "Blk1OType",
    "Blk1ObjDBId",
    "Blk1ObjTId",
    "Blk1Status",
    "Blk2HostId",
    "Blk2SessNo",
    "Blk2UserId",
    "Blk2LMode",
    "Blk2OType",
    "Blk2ObjDBId",
    "Blk2ObjTId",
    "Blk2Status",
    "Blk3HostId",
    "Blk3SessNo",
    "Blk3UserId",
    "Blk3LMode",
    "Blk3OType",
    "Blk3ObjDBId",
    "Blk3ObjTId",
    "Blk3Status",
    "MoreBlockers",
    "LogonSource",
    "TempSpaceUsage",
    "HotAmp1CPU",
    "HotAmp2CPU",
    "HotAmp3CPU",
    "HotAmp1IO ",
    "HotAmp2IO ",
    "HotAmp3IO ",
    "HotAmp1CPUId",
    "HotAmp2CPUId",
    "HotAmp3CPUId",
    "HotAmp1IOId",
    "HotAmp2IOId",
    "HotAmp3IOId",
    "LowAmp1CPU",
    "LowAmp2CPU",
    "LowAmp3CPU",
    "LowAmp1IO ",
    "LowAmp2IO ",
    "LowAmp3IO ",
    "LowAmp1CPUId",
    "LowAmp2CPUId",
    "LowAmp3CPUId",
    "LowAmp1IOId",
    "LowAmp2IOId",
    "LowAmp3IOId",
    "AmpCount",
    "AvgAmpCPUSec",
    "AvgAmpIOCnt",
    "ReqStartTime",
    "ReqStartDate",
    "ReqCPU",
    "ReqIO",
    "RequestNo",
    "WlcId",
    "DontReclassifyFlag",
};
 
/* This routine displays the presence bits along with the field name. */
static void PrintPresenceBits(char *ptr,int fieldcount,char **fieldnamelist)
{
    char *tempptr=ptr;
    char temp = *ptr;
    int i=0;
    int bitOn;
    char buf[200];
    int endlist=0;
 
    printf("\nPresence Bits:\n");
    while (i < fieldcount)
    {
        bitOn = (temp & (char)0x80);
 
        if (!endlist)
        {
            if (!fieldnamelist  ||
               (fieldnamelist && strlen(fieldnamelist[i]) == 0))
                endlist = 1;
        };
 
        if (endlist)
        {
            sprintf(buf,"Field%03d",i+1);
        }
        else
            strcpy(buf,fieldnamelist[i]);
 
        if (bitOn)
            printf("[%02d] %30s \tis \tNULL\n",i,buf);
        else
            printf("[%02d] %30s \tis \tNOT NULL\n",i,buf);
 
        i++;
        if ((i % 8) == 0)
        {
            tempptr++;
            temp = *tempptr;
        }
        else
            temp = temp << 1;
    }
    printf("\n");
}
 
/***************************************************************/
/* WRITE_ERROR -- Prints error message that is located in      */
/*                the response buffer--Error or Failure Parcel */
/***************************************************************/
static void Write_error(char *parcel)
  int i;
  Error_Fail_t *Error_Fail;
  Error_Fail = ((struct ERROR_FAIL_Type *) (parcel));
  printf("DBS Error code: %d : ",Error_Fail->Code);
  for(i=0;i < (int)Error_Fail->Length;i++)
    printf("%c",Error_Fail->Msg[i]);
  printf("\n");
} /**end write_error**/
 
/* MONITOR SESSION formatting routines */  
static void PrtSes1(char *dataptr)
{
  short *SampleRate;
 
  SampleRate = (short *) (dataptr);
  printf("Sample rate: %d seconds\n\n", *SampleRate);
 
}
 
static void PrtSes2(char *dataptr, int version)
{
    MonSesRec2_t  *MonSesRec2;
    MonSesRecV3_t *MonSesRecV3;
    MonSesRecV4_t *MonSesRecV4;
    MonSesRecV5_t *MonSesRecV5;
 
    MonSesRec2 = (MonSesRec2_t *) (dataptr);
 
    if (version >= MONVERSION3)
    {
      MonSesRecV3 = (MonSesRecV3_t *)(((char *) (&MonSesRec2->LogonSource)) +
                       MonSesRec2->LogonSourceLen);
    }
 
    if (version >=MONVERSION4)
    {
      MonSesRecV4 = (MonSesRecV4_t *) (MonSesRecV3 +1);
    }
 
    if (version >=MONVERSION5)
    {
      MonSesRecV5 = (MonSesRecV5_t *) (MonSesRecV4 +1);
    }
 
    printf("HostId: %8d   ", MonSesRec2->HostId);
    printf("SessionNo: %d\n", MonSesRec2->SessionNo);
    printf("LogonPENo: %5d   ", MonSesRec2->LogonProcId);
    printf("RunVprocNo: %5d\n", MonSesRec2->RunProcId);
    printf("PartName: %.16s", MonSesRec2->PartName);
    printf("PEState:  %.18s\n\n", MonSesRec2->PEState);
 
    printf("LogonDate: %04d/%02d/%02d         ", 
        (int) MonSesRec2->LogonDate / 10000 + 1900,
        (int) MonSesRec2->LogonDate / 100 % 100, 
        (int) MonSesRec2->LogonDate % 100);
    printf("LogonTime: %02d:%02d:%05.2f\n", 
        (int) MonSesRec2->LogonTime / 10000,
        (int) MonSesRec2->LogonTime / 100 % 100, 
        (int) MonSesRec2->LogonTime % 100 + 
        MonSesRec2->LogonTime - 
        (int) MonSesRec2->LogonTime);
    printf("UserID: %d ", MonSesRec2->UserID);
    printf("LSN: %d\n", MonSesRec2->LSN);
    printf("UserName: %.30s\n", MonSesRec2->UserName);
    printf("UserAccount: %.30s\n\n", MonSesRec2->UserAccount);
 
    printf("PECPUSec: %10.2f   ", MonSesRec2->PECPUSec);
    printf("XactCount: %13.2f\n", MonSesRec2->XactCount);
    printf("ReqCount: %10.1f   ", MonSesRec2->ReqCount);
    printf("ReqCacheHits: %10.1f\n\n", MonSesRec2->ReqCacheHits);
 
    printf("AMPState: %.18s\n", MonSesRec2->AMPState);
    printf("AMPCPUSec: %9.2f   ", MonSesRec2->AMPCPUSec);
    printf("AMPIO: %7.2f\n", MonSesRec2->AMPIO);
    printf("Request_AMPSpool: %4.1f\n\n", MonSesRec2->Delta_AMPSpool);
 
    printf("Blk_1_HostId: %6d   ", MonSesRec2->Blk_1_HostId);
    printf("Blk_2_HostId: %6d   ", MonSesRec2->Blk_2_HostId);
    printf("Blk_3_HostId: %6d\n", MonSesRec2->Blk_3_HostId);
 
    printf("Blk_1_SessNo: %6d   ", MonSesRec2->Blk_1_SessNo);
    printf("Blk_2_SessNo: %6d   ", MonSesRec2->Blk_2_SessNo);
    printf("Blk_3_SessNo: %6d\n", MonSesRec2->Blk_3_SessNo);
 
    printf("Blk_1_UserID: %6d   ", MonSesRec2->Blk_1_UserID);
    printf("Blk_2_UserID: %6d   ", MonSesRec2->Blk_2_UserID);
    printf("Blk_3_UserID: %6d\n", MonSesRec2->Blk_3_UserID);
 
    printf("Blk_1_LMode: %c         ", MonSesRec2->Blk_1_LMode);
    printf("Blk_2_LMode: %c         ", MonSesRec2->Blk_2_LMode);
    printf("Blk_3_LMode: %c\n", MonSesRec2->Blk_3_LMode);
 
    printf("Blk_1_OType: %c         ", MonSesRec2->Blk_1_OType);
    printf("Blk_2_OType: %c         ", MonSesRec2->Blk_2_OType);
    printf("Blk_3_OType: %c\n", MonSesRec2->Blk_3_OType);
 
    printf("Blk_1_ObjDBId: %5d   ", MonSesRec2->Blk_1_ObjDBId);
    printf("Blk_2_ObjDBId: %5d   ", MonSesRec2->Blk_2_ObjDBId);
    printf("Blk_3_ObjDBId: %5d\n", MonSesRec2->Blk_3_ObjDBId);
 
    printf("Blk_1_ObjTId: %6d   ", MonSesRec2->Blk_1_ObjTId);
    printf("Blk_2_ObjTId: %6d   ", MonSesRec2->Blk_2_ObjTId);
    printf("Blk_3_ObjTId: %6d\n", MonSesRec2->Blk_3_ObjTId);
  
    printf("Blk_1_Status: %c        ", MonSesRec2->Blk_1_Status);
    printf("Blk_2_Status: %c        ", MonSesRec2->Blk_2_Status);
    printf("Blk_3_Status: %c\n", MonSesRec2->Blk_3_Status);
    printf("MoreBlockers: %c\n\n", MonSesRec2->MoreBlockers);
    MonSesRec2->LogonSource[MonSesRec2->LogonSourceLen] = '\0';
    printf("LogonSource: %.128s\n\n", MonSesRec2->LogonSource);
 
 
    /* MonVerId 3 fields */
    if (version < MONVERSION3)
        return;
 
    printf("HotAmp1CPU: %9.2f   ", MonSesRecV3->HotAmp1CPU);
    printf("HotAmp2CPU: %9.2f   ", MonSesRecV3->HotAmp2CPU);
    printf("HotAmp3CPU: %9.2f\n", MonSesRecV3->HotAmp3CPU);
 
    printf("HotAmp1CPUId: %7d   ", MonSesRecV3->HotAmp1CPUId);
    printf("HotAmp2CPUId: %7d   ", MonSesRecV3->HotAmp2CPUId);
    printf("HotAmp3CPUId: %7d\n\n", MonSesRecV3->HotAmp3CPUId);
 
    printf("HotAmp1IO: %10.2f   ", MonSesRecV3->HotAmp1IO);
    printf("HotAmp2IO: %10.2f   ", MonSesRecV3->HotAmp2IO);
    printf("HotAmp3IO: %10.2f\n", MonSesRecV3->HotAmp3IO);
 
    printf("HotAmp1IOId: %8d   ", MonSesRecV3->HotAmp1IOId);
    printf("HotAmp2IOId: %8d   ", MonSesRecV3->HotAmp2IOId);
    printf("HotAmp3IOId: %8d\n\n", MonSesRecV3->HotAmp3IOId);
 
    printf("LowAmp1CPU: %9.2f   ", MonSesRecV3->LowAmp1CPU);
    printf("LowAmp2CPU: %9.2f   ", MonSesRecV3->LowAmp2CPU);
    printf("LowAmp3CPU: %9.2f\n", MonSesRecV3->LowAmp3CPU);
 
    printf("LowAmp1CPUId: %7d   ", MonSesRecV3->LowAmp1CPUId);
    printf("LowAmp2CPUId: %7d   ", MonSesRecV3->LowAmp2CPUId);
    printf("LowAmp3CPUId: %7d\n\n", MonSesRecV3->LowAmp3CPUId);
 
    printf("LowAmp1IO: %10.2f   ", MonSesRecV3->LowAmp1IO);
    printf("LowAmp2IO: %10.2f   ", MonSesRecV3->LowAmp2IO);
    printf("LowAmp3IO: %10.2f\n", MonSesRecV3->LowAmp3IO);
 
    printf("LowAmp1IOId: %8d   ", MonSesRecV3->LowAmp1IOId);
    printf("LowAmp2IOId: %8d   ", MonSesRecV3->LowAmp2IOId);
    printf("LowAmp3IOId: %8d\n\n", MonSesRecV3->LowAmp3IOId);
 
    printf("AvgAmpCPUSec:%8.2f   ", MonSesRecV3->AvgAmpCPUSec);
    printf("AvgAmpIOCnt: %8.2f\n", MonSesRecV3->AvgAmpIOCnt);
    printf("AmpCount: %11d\n\n", MonSesRecV3->AmpCount);
 
    printf("TempSpaceUsg: %7.2f\n\n", MonSesRecV3->TempSpaceUsage); 
 
    if (version <MONVERSION4)
        return;
 
    /* MonVerId 4 fields */
    printf("ReqStartTime: %04d/%02d/%02d  ", 
        (int) MonSesRecV4->ReqStartDate / 10000 + 1900,
        (int) MonSesRecV4->ReqStartDate / 100 % 100, 
        (int) MonSesRecV4->ReqStartDate % 100);
    printf("%02d:%02d:%05.2f", 
        (int) MonSesRecV4->ReqStartTime / 10000,
        (int) MonSesRecV4->ReqStartTime / 100 % 100, 
        (int) MonSesRecV4->ReqStartTime % 100 + 
        MonSesRecV4->ReqStartTime - 
        (int) MonSesRecV4->ReqStartTime);
 
    printf("  ReqCPU: %10.2f", MonSesRecV4->ReqCPU);
    printf("  ReqIO: %10.2f\n", MonSesRecV4->ReqIO);
 
    if (version <MONVERSION5)
        return;
 
    /* MonVerId 5 fields */
    printf("ReqNo:%d   WlcId: %d     DontReclassifyFlag: %d\n", 
        MonSesRecV5->ReqNo,          
       MonSesRecV5->WlcId,MonSesRecV5->DontReclassifyFlag);
 
}
 
static void CheckSuccess(int ActivityType,
                         int ActivityCount,
                         int StatementNo)
{
    switch (ActivityType)
    {
        case PCLSTMTNULL:                          
            printf("Null statement successful. \n\n"); 
            break;                                 
 
    }
    return;
}
 
 
static void CheckData(int ActivtyType, int StatementNo)
{
   DataInfo_t * DataInfo;
   int          i;
 
   DataInfo = (DataInfo_t *) (dbc.fet_data_ptr);
   printf("\nCheckData called for Indicator mode data info parcel.\n"); 
   printf("Field Count: %d \n", DataInfo->field_count);
 
   IndicFieldCount  = DataInfo->field_count;
 
   if (DataInfo->field_count > MAXFIELDS)   
       DataInfo->field_count = MAXFIELDS;
 
   for (i = 0; i < DataInfo->field_count; i++)
   {
        printf("Field %d: Type = %d Size = %d\n", i + 1,
            DataInfo->FieldData[i].FType,
            DataInfo->FieldData[i].FSize);
   }
 
   return;
}
 
static void CheckRecord(int ActivtyType, int StatementNo, int ActivityCount)
{
    switch (ActivtyType)
    {       
        case PCLMONSESS:
            if (StatementNo == 1)
                PrtSes1(dbc.fet_data_ptr);
            else if (StatementNo == 2)
            {
                int IndLen=0;  
 
                if (IndicatorMode)         
                {   
                    switch (TargetVersion)
                    {
                    case MONVERSION3:
                    case MONVERSION4:
                       IndLen = 10; 
                       break;
                    case MONVERSION5:
                    case MONVERSION6:
                    default:
                       IndLen = 11; 
                       break;
                    }
 
                    PrintPresenceBits(dbc.fet_data_ptr,IndicFieldCount,MonSesRec2fieldnamelist); 
                    dbc.fet_data_ptr = (char *)dbc.fet_data_ptr + IndLen;    
                }                   
 
                PrtSes2(dbc.fet_data_ptr,TargetVersion); 
                printf("\n");
                printf("----------------------------------------------------\n\n");
            }
            break;
 
        default:
            printf("\nFound a funny parcel number: %d\n",ActivtyType);
            break;
    }
}
 
/***************************************************************/
/*  SET_OPTIONS -- sets cli options (record,field,indicator    */
/*                 mode; etc..)                                */
/*                 Sets size of buffers (request and response) */
/***************************************************************/
set_options()
{
    dbc.change_opts = 'Y';
    dbc.resp_mode = 'R';
    dbc.use_presence_bits = 'Y';
    dbc.keep_resp = 'N';
    dbc.wait_across_crash = 'N';
    dbc.tell_about_crash = 'Y';
    dbc.loc_mode = 'Y';
    dbc.var_len_req = 'N';
    dbc.var_len_fetch = 'N';
    dbc.save_resp_buf = 'N';
    dbc.two_resp_bufs = 'N';
    dbc.ret_time = 'N';
    dbc.parcel_mode = 'Y';
    dbc.wait_for_resp = 'Y';
    dbc.req_proc_opt = 'E';
 
    dbc.req_buf_len = 256;
    dbc.resp_buf_len = 32000; 
 
    return(0);
} /**end set_options**/
 
 
/***************************************************************/
/* EXITOUT -- If connected logs off session. Cleans up         */
/*            any used memory.                                 */
/***************************************************************/
void exitout(int status)
{
    Int32  result;
 
    if (status == CONNECTED)
    { 
        printf ("Logging off.\n");
        dbc.func = DBFDSC;
        DBCHCL (&result,cnta,&dbc);
        if (result != EM_OK)
            printf("disconnect failed -- %s\n", dbc.msg_text);
    }
 
    DBCHCLN(&result,cnta);
    if (result != EM_OK)
        printf("cleanup failed -- %s\n", dbc.msg_text);
 
    exit(0);
} /**end exitout**/
 
 
/***************************************************************/
/* INITIALIZE_DBCAREA -- Sets default options (clispb.dat) in  */
/*                       dbcarea by calling DBCHINI()          */
/***************************************************************/
initialize_dbcarea()
{
    Int32  result;
 
    dbc.total_len = sizeof(struct DBCAREA);
    DBCHINI(&result,cnta,&dbc);
    if (result != EM_OK)
    { /* if we can't initialize, we can't go on, so exit */
        printf("init failed -- %s\n", dbc.msg_text);
        exitout(NOT_CONNECTED);
    }
    return(0);
}  /**end initialize_dbcarea**/
 
/***************************************************************/
/* LOGON_TO_DBC -- Connects session and logs on to DBC         */
/*                 Fetches result of connection to check if    */
/*                 successful                                  */
/***************************************************************/
logon_to_dbc(char * logonstr)
    struct  CliCONNECTType connectstr;
    Int32   result, i;
    char    TempString[30];
 
    for (i = 0; i < 30; i++)
        TempString[i] = ' ';
 
    for (i = 0; i < 30; i++)
    {
        if (logonstr[i] == '/')
        {
            TempString[i] = '\0';
            break;
        }
        TempString[i] = logonstr[i];
    }
    printf("Logging on to %s ...\n", TempString);
 
    dbc.logon_ptr = logonstr;
    dbc.logon_len = strlen(logonstr);
    dbc.func = DBFCON;
    dbc.run_ptr = (char *) &connectstr;
    strncpy(connectstr.PartitionName, "MONITOR         ", 16);
    connectstr.Function = 0;
    dbc.run_len = sizeof(struct CliCONNECTType);
 
    DBCHCL(&result,cnta,&dbc);
    if (result != EM_OK)  /*if connect fails exit*/
    { 
        printf("connect failed -- %s\n",dbc.msg_text);
        exitout(NOT_CONNECTED);
    }
 
    printf("Logon successful.\n");
    return(0);
} /**end logon_to_dbc**/
 
 
/***************************************************************/
/* CLOSE_REQUEST -- Terminates and cleans up specified request */
/***************************************************************/
close_request(Int32 req_id, Int32 sess_id)
{
    Int32  result;
 
    dbc.i_sess_id = sess_id;
    dbc.i_req_id = req_id;
    dbc.func=DBFERQ;
 
    DBCHCL(&result,cnta,&dbc);
 
    if (result !=EM_OK)
    {
        printf("end request failed -- %s\n", dbc.msg_text);
        exitout(CONNECTED);
    }
    return(0);
} /**end close_request**/
 
 
/***************************************************************/
/* OPEN_REQUEST -- Sends request to DBC                        */
/***************************************************************/
open_request (int InReqType,
              void *UsingPtr)
{
    Int32   result;
    char    CurrRequestText[32];
                                  
    /* set up for a new request */
 
    dbc.func = DBFIRQ;            
    dbc.using_data_ptr = (char *) UsingPtr; 
  
    switch (InReqType)
    {
        case MON_SESS_REQ:
            strcpy(CurrRequestText,"MONITOR SESSION;");
            dbc.using_data_len = sizeof(monsess_t);
            break;
        default: 
            printf("Internal error\n");
            exitout(CONNECTED);
    }
 
    dbc.req_ptr = &CurrRequestText[0];
    dbc.req_len = strlen (CurrRequestText);
 
    printf ("\nSubmitting request %s ...\n", dbc.req_ptr); 
                                                          
    /* Submit request */
    DBCHCL (&result,cnta,&dbc);
    if (result != EM_OK)
    {
        printf ("result = %d \n", result);
        printf ("initiate request failed -- %s \n", dbc.msg_text);
        exitout(CONNECTED);
    }
 
    return(EM_OK);
} /**end open_request**/
 
 
int fetch_request(Int32 request, Int32 session)
    int     status;
    int     StatementNo = 0;
    int     ActivityType = 0;
    int     ActivityCount = 0;
    Int32   result;
    int     ReturnCode;
 
    dbc.i_sess_id = session;
    dbc.i_req_id = request;
    dbc.func = DBFFET;
    status = OK;
    ReturnCode = OK;
 
    /* fetch one parcel at a time until all parcels are used up  */
    /* or an error occurs */
 
    while (status == OK)
    { 
        DBCHCL(&result,cnta,&dbc);
        if (result == REQEXHAUST) 
            status = STOP;
        else if (result != EM_OK) 
            status = NOT_OK;
        else
        {
            switch ((Int16) (dbc.fet_parcel_flavor))
            { 
               case PCLSUCCESS :                        /*Success Parcel */
                   {
                    struct  PclSUCCESSType   succ;
                    memcpy(&succ,dbc.fet_data_ptr-4,4);
                    memcpy(&succ,dbc.fet_data_ptr-4,succ.Length+4);
                    StatementNo = succ.StatementNo;
                    ActivityCount = *(int *)(&succ.ActivityCount[0]);
                    ActivityType = succ.ActivityType;
                    if ( succ.WarningLength > 0 )
                        printf("%s \n", succ.WarningMsg);
 
                    CheckSuccess(ActivityType, ActivityCount, StatementNo);
                    }
                    break;
 
                case PclDATAINFO :                        
                    CheckData(ActivityType, StatementNo);
                    break;
                case PclRECORD :                         /*Returned data */
                    CheckRecord(ActivityType, StatementNo, ActivityCount);
                    break;
                case PclFAILURE :                        /*Failure parcel*/
                case PclERROR :                          /*Error parcel  */
                    status = STOP;
                    Write_error(dbc.fet_data_ptr);
                    ReturnCode = PclERROR;
                    break;
            } /*switch*/
        }
    } /*while*/
 
    if (status == NOT_OK)
    { 
        printf("fetch failed -- %s \n", dbc.msg_text);
        exitout(CONNECTED);
    } /*if*/
 
    return(ReturnCode);
} /**end fetch_request**/
 
 
static Boolean MonSession()
{
    monsess_t   MonSess;
    int         i;
    char        InString[MAXNAME];
 
    /* Initializations */
    MonSess.monheader.version  = TargetVersion;
    MonSess.monheader.indicbyte = '\0';
    for (i = 0; i < MAXNAME; i++)
        monsess.user[i] = ' ';
 
    printf("Enter logical hostid (* for all hosts) or Q)uit: ");
    gets(InString);
    if (!strcmp(InString, "*") || (strlen(InString) == 0))
        MonSess.hostid = (Int16) 65535; 
    else if (!strcmp(InString, "Q") || !strcmp(InString, "q"))
        return (TRUE);
    else
        MonSess.hostid = atoi(InString);
 
    printf("Enter user name (* for all users): ");
    gets(InString);
    if (!strcmp(InString, "*") || (strlen(InString) == 0))
    {
        for (i = 0; i < MAXNAME; i++)
        {
            if (InString[i] == '\0')
                break;
            MonSess.user[i] = InString[i];
        }
    }
 
    printf("Enter session number (* for all sessions): ");
    gets(InString);
    if (!strcmp(InString, "*") || (strlen(InString) == 0))
        MonSess.session = 0;
    else
        MonSess.session = atoi(InString);
 
    if (RespMode == 'I' || RespMode == 'i')
    {
        dbc.resp_mode = 'I';
        IndicatorMode = TRUE;
    }
    else
    {
        dbc.resp_mode = 'R';
        IndicatorMode = FALSE;
    }
 
    open_request( MON_SESS_REQ,&MonSess);
    fetch_request(dbc.o_req_id, dbc.o_sess_id);
    close_request(dbc.o_req_id, dbc.o_sess_id);
 
    return (FALSE);
 
}
 
 
main (int argc, char **argv)
{
    char    LogonString[MAXLOGONSIZE];
    Boolean stop = FALSE;
 
    initialize_dbcarea();
    set_options();
  
    //6: Teradata 12.x;  5: Teradata 6.x  4: Teradata 5.x
    TargetVersion = 6;  
 
    // 'R' no presence bits returned; 'I' presence bits returned
    RespMode = 'I';  
    IndicatorMode = TRUE;
 
    printf ("TargetVersion(argv1) = %d, RespMode(argv2) = %c \n\n",
            TargetVersion, RespMode);
 
    /* Establish session */
    printf ("Enter logon string (tdpid/user,password): ");
    gets (LogonString);
    if (strlen(LogonString) == 0)
    {
       printf ("NULL logon string not accepted.\n");
       return (1);
    }
  
    logon_to_dbc(LogonString);
    if (fetch_request(dbc.o_req_id,dbc.o_sess_id) != OK)
       exitout(NOT_CONNECTED);
    close_request(dbc.o_req_id,dbc.o_sess_id);
 
 
    while (stop == FALSE)
       stop = MonSession();
 
    /* Logoff and cleanup */
    exitout(CONNECTED);
    return 0;
} /**end main**/