/***************************************************************************
*	Licensed Materials - Property of HCL Technologies
*
*	"Restricted Materials of HCL"
*
*	HCL Informix ODBC Application
*
*	Copyright HCL 2020 All rights reserved.
*
*  Title:          SmartTrigger.c
*
*  Description:    Direct Push Data/Smart Trigger ODBC application
*
*  Author  : Sheshnarayan Agrawal
*
*** TODO : 1. Support commented options in the help menu.
*
***************************************************************************
*/


#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#ifndef NO_WIN32
#include <io.h>
#include <windows.h>
#include <conio.h>
#endif /*NO_WIN32*/

#include "infxcli.h"

#define ERRMSG_LEN         200
/* Max number of tables demo program can handle */
#define MAXTAB             20
#define SQL_STMT_LEN       8192
#define IDS_MAX_LEN        1024
#define JSON_DATA_LEN      8192
/* Display length of the column values */
#define DISPLAY_LEN        31
#define NAMELEN            100
#define MAXARGSIZE         512
#define DB_OBJECT_LENGTH   128
#define SQL_QUERY_LENGTH   8192

SQLCHAR   defDsn[] = "SmartTrigger";

SQLINTEGER     no_of_tab = -1;
SQLINTEGER     no_of_own = -1;
SQLINTEGER     no_of_sel = -1;
SQLINTEGER     max_ops = 0;
SQLINTEGER     maxrecs = 1;
//bigint txnid = 0;
SQLINTEGER     detach = 0;
SQLINTEGER     join = 0;
SQLINTEGER     delete = 0;
SQLINTEGER     timeout = 300;
SQLINTEGER     max_recs_per_read = 1;
SQLINTEGER     showData = 1;

SQLSMALLINT    tableCounter = 0;
SQLSMALLINT    ownerCounter = 0;
SQLSMALLINT    selectCounter = 0;
SQLSMALLINT    dbCounter = 0;
SQLSMALLINT    lableCounter = 0;

/* Test related variables */
SQLCHAR        datafile[512] = { 0 };

SQLHDBC        hdbc;
SQLHENV        henv;
SQLINTEGER     sesID;

SQLCHAR        outfile[DB_OBJECT_LENGTH+1] = { 0 };
SQLCHAR        dsnName[NAMELEN + 1] = { 0 };

typedef struct tagIfmxRegisterTrigger
{
	void(*callback)
		(char *jsonOutBuf);
	SQLINTEGER   sessionID;
	SQLCHAR     *tableName; //Max value length 128
	SQLCHAR     *ownerName; //Max value length 128
	SQLCHAR     *dbName;    //Max value length 128
	SQLCHAR     *sqlQuery;  //Max value length 32K
	SQLCHAR     *label;     //Max value length 128
	BOOL        isDetachable; //Default False
	BOOL        isDelete;     //Default True
	SQLINTEGER  timeOut; //Default 120 secs
	SQLINTEGER  joinSessionID; //Default 0
	SQLSMALLINT maxRecsPerRead; //Default 1
	SQLINTEGER  maxPendingOperations; //Default 0
} IFMX_SMART_TRIGGER;

struct InputData
{
	SQLSMALLINT myCount;
	SQLCHAR tableName[DB_OBJECT_LENGTH + 1];
	SQLCHAR ownerName[DB_OBJECT_LENGTH + 1];
	SQLCHAR dbName[DB_OBJECT_LENGTH + 1];
	SQLCHAR sqlQuery[SQL_QUERY_LENGTH + 1];
	SQLCHAR pdLable[DB_OBJECT_LENGTH + 1];
};

struct InputData inputValues[MAXTAB];

SQLINTEGER checkError (SQLRETURN       rc,
                       SQLSMALLINT     handleType,
                       SQLHANDLE       handle,
                       SQLCHAR*        errmsg)
{
    SQLRETURN       retcode = SQL_SUCCESS;

    SQLSMALLINT     errNum = 1;
    SQLCHAR		    sqlState[6];
    SQLINTEGER      nativeError;
    SQLCHAR		    errMsg[ERRMSG_LEN];
    SQLSMALLINT     textLengthPtr;


    if ((rc != SQL_SUCCESS) && (rc != SQL_SUCCESS_WITH_INFO))
    {
        while (retcode != SQL_NO_DATA)
        {
            retcode = SQLGetDiagRec (handleType, handle, errNum, sqlState, &nativeError, errMsg, ERRMSG_LEN, &textLengthPtr);

            if (retcode == SQL_INVALID_HANDLE)
            {
                fprintf (stderr, "checkError function was called with an invalid handle!!\n");
                return 1;
            }

            if ((retcode == SQL_SUCCESS) || (retcode == SQL_SUCCESS_WITH_INFO))
                fprintf (stderr, "ERROR: %d:  %s : %s \n", nativeError, sqlState, errMsg);

            errNum++;
        }

        fprintf (stderr, "%s\n", errmsg);
        return 1;   /* all errors on this handle have been reported */
    }
    else
        return 0;	/* no errors to report */
}


void Usage(char *progname)
{
	fprintf(stdout, "\tVersion : 1.0  29 March 2018\n");
	//fprintf(stdout, "\tUsage : %s [-DSN <ODBC DSN Name>] -D <Database> -T <Table> -O <Owner> -S <Select Query> [-Lable <Label>] [-Timeout <Timeout>] [-L <8 byte txn id - start lsn>]  \n",
	//	progname);
	fprintf(stdout, "\tUsage : %s [-DSN <ODBC DSN Name>] -D <Database> -T <Table> -O <Owner> -S <Select Query> [-Lable <Label>] [-Timeout <Timeout>]  [-Show <1/0>] [-M <Pending operations>] [-R <Records per read>] [-F <File name>] [-J <Join session ID>] [-P] [-C] \n",
		progname);
	fprintf(stdout, "\nCommand Line Options are :\n");
	fprintf(stdout, "\t-DSN <ODBC DSN Name, Default is \"SmartTrigger\">\n");
	fprintf(stdout, "\t-h/? <Help options of the program>\n");
	fprintf(stdout, "\t-D[-Database] <Database name where table belongs>\n");
	fprintf(stdout, "\t-T[-Table] <Name of the table to be captured>\n");
	fprintf(stdout, "\t-O[-Owner] <Table owner>\n");
	fprintf(stdout, "\t-S[-Select] <Select statement with/without WHERE clause>\n");
	fprintf(stdout, "\t-Show <1/0, Show push data on the console. Default is 1(ON).>\n");
	fprintf(stdout, "\t-Timeout <Timeout in second>\n");
	fprintf(stdout, "\t\tDefault: 300 sec\n");
	//fprintf(stdout, "\t-L[-Lsn] <LSN to start capture. Format \"8 byte txnid, 4 ( byte 8 to 5) byte uniq id and 4 (1 to 4) byte logpos\">\n");
	//fprintf(stdout, "\t\tDefault: current LSN\n");
	fprintf(stdout, "\t-Lable <User specified label/comment.>\n");
	fprintf(stdout, "\t-M <Maximum number of pending operations>\n");
	fprintf(stdout, "\t-R[-Read] <Maximum number of records per read. Default value is 1.>\n");
	fprintf(stdout, "\t-F[-FileName] <Name of the file (will be created in current path) to dump the Push data json records>\n");
	fprintf(stdout, "\t-P <Set session as a persistent detachable session by just specifying -P, it doesn't take any parameter value.>\n");
	fprintf(stdout, "\t-J <Join with unique session id, which was returned from previous call of pushdata registration.>\n");
	fprintf(stdout, "\t-C <Delete event conditions by just specifying -C, it doesn't take any parameter value.>\n");
	fprintf(stdout, "\nProgram Description\n");
	fprintf(stdout, "\tThis program captures one/more tables data of registered select query. Program terminates when timeout record is received.\n");
	fprintf(stdout, "\tProviding Database(-D), Table(-T), Owner(-O) and Select Query(-S) parameters are mandatory for each table. \n");
	fprintf(stdout, "\n\tExample:\n");
	fprintf(stdout, "\t%s -DSN \"PushDataDsn\" -D db1 -T \"t1\" -O \"bill\" -S \"select a,b from t1\" -D db1 -T t2 -O \"bill\" -S \"select a,c from t2\" -Timeout 60\n", progname);
	exit(0);
}

void ProcessOption(int ac, char *av[])
{
	int         i;
	char        lsn_string[1024];
	char*       token;

	if (ac <= 1)
	{
		printf("Not supported options are detected OR options provided are incorrect/not sufficient, for more information run \"%s -h\"", av[0]);
		exit(-1);
	}

	/* Avoid using getopt to avoid Windows portability issues. */
#define CHECK_FOR_REQUIRED_ARG                                              \
    if ((i + 1 >= ac) || av[i+1][0] == '-') Usage(av[0])
#define GOBBLE_ARG                                                          \
    i++;

	i = 1;
	while (i < ac)
	{
		if ( (strcmp(av[i], "-S")==0) || (strcmp(av[i], "-Select")==0) )
		{
			CHECK_FOR_REQUIRED_ARG;
			no_of_sel++;
			if (selectCounter > MAXTAB)
			{
				printf("Select query counter exceeded %d limit, adjust the parameters and retry.", MAXTAB);
				exit(0);
			}
			strncpy(inputValues[selectCounter].sqlQuery, av[i + 1], SQL_QUERY_LENGTH);
			inputValues[selectCounter].sqlQuery[SQL_QUERY_LENGTH] = 0;
			selectCounter++;
			GOBBLE_ARG;
		}
		else if ( (strcmp(av[i], "-D") == 0) || (strcmp(av[i], "-Database") == 0))
		{
			CHECK_FOR_REQUIRED_ARG;
			if (dbCounter > MAXTAB)
			{
				printf("Database counter exceeded %d limit, adjust the parameters and retry.", MAXTAB);
				exit(0);
			}
			strncpy(inputValues[dbCounter].dbName, av[i + 1], DB_OBJECT_LENGTH);
			inputValues[dbCounter].dbName[DB_OBJECT_LENGTH] = 0;
			dbCounter++;
			GOBBLE_ARG;
		}
		else if ( (strcmp(av[i], "-T") == 0) || (strcmp(av[i], "-Table") == 0))
		{
			CHECK_FOR_REQUIRED_ARG;
			no_of_tab++;
			if (tableCounter > MAXTAB)
			{
				printf("Table counter exceeded %d limit, adjust the parameters and retry.", MAXTAB);
				exit(0);
			}
			strncpy(inputValues[tableCounter].tableName, av[i + 1], DB_OBJECT_LENGTH);
			inputValues[tableCounter].tableName[DB_OBJECT_LENGTH] = 0;
			inputValues[tableCounter].myCount = tableCounter+1;
			tableCounter++;
			GOBBLE_ARG;
		}
		else if ( (strcmp(av[i], "-O") == 0) || (strcmp(av[i], "-Owner") == 0) )
		{
			CHECK_FOR_REQUIRED_ARG;
			no_of_own++;
			if (ownerCounter > MAXTAB)
			{
				printf("Owner counter exceeded %d limit, adjust the parameters and retry.", MAXTAB);
				exit(0);
			}
			strncpy(inputValues[ownerCounter].ownerName, av[i + 1], DB_OBJECT_LENGTH);
			inputValues[ownerCounter].ownerName[DB_OBJECT_LENGTH] = 0;
			ownerCounter++;
			GOBBLE_ARG;
		}
		else if ((strcmp(av[i], "-R") == 0) || (strcmp(av[i], "-Read") == 0))
		{
			CHECK_FOR_REQUIRED_ARG;
			char *endptr;
			max_recs_per_read = strtol(av[i + 1], &endptr, 0);
			if (endptr && endptr[0] != '\0' && !isspace(endptr[0]))
			{
				fprintf(stderr, "Invalid data entered for -Read option %s\n", endptr);
				exit(-1);
			}
			GOBBLE_ARG;
		}
		else if ((strcmp(av[i], "-F") == 0) || (strcmp(av[i], "-FileName") == 0))
		{
			CHECK_FOR_REQUIRED_ARG;
			memset(outfile, 0, sizeof(outfile));
			strncpy(outfile, av[i + 1], DB_OBJECT_LENGTH);
			outfile[DB_OBJECT_LENGTH] = '\0';
			GOBBLE_ARG;
		}
		else if ( (strcmp(av[i], "-DSN") == 0) )
		{
			CHECK_FOR_REQUIRED_ARG;
			memset(dsnName, 0, sizeof(dsnName));
			strncpy(dsnName, av[i + 1], NAMELEN);
			outfile[NAMELEN] = '\0';
			GOBBLE_ARG;
		}
		else if (strcmp(av[i], "-Show") == 0)
		{
			CHECK_FOR_REQUIRED_ARG;
			char *endptr;
			showData = strtol(av[i + 1], &endptr, 0);
			if (endptr && endptr[0] != '\0' && !isspace(endptr[0]))
			{
				fprintf(stderr, "Invalid data enetered for display -Show option %s\n", endptr);
				exit(-1);
			}
			GOBBLE_ARG;
		}
		else if (strcmp(av[i], "-Timeout") == 0)
		{
			CHECK_FOR_REQUIRED_ARG;
			char *endptr;
			timeout = strtol(av[i + 1], &endptr, 0);
			if (endptr && endptr[0] != '\0' && !isspace(endptr[0]))
			{
				fprintf(stderr, "Invalid data enetered for timeout -Timeout option %s\n", endptr);
				exit(-1);
			}
			GOBBLE_ARG;
		}
		else if (strcmp(av[i], "-Lable") == 0)
		{
			CHECK_FOR_REQUIRED_ARG;
			if (ownerCounter > MAXTAB)
			{
				printf("Owner counter exceeded %d limit, adjust the parameters and retry.", MAXTAB);
				exit(0);
			}
			strncpy(inputValues[lableCounter].pdLable, av[i + 1], DB_OBJECT_LENGTH);
			inputValues[lableCounter].pdLable[DB_OBJECT_LENGTH] = 0;
			lableCounter++;
			GOBBLE_ARG;
		}
		/*else if ( (strcmp(av[i], "-L") == 0) || (strcmp(av[i], "-Lsn") == 0))
		{
			CHECK_FOR_REQUIRED_ARG;
			strncpy(lsn_string, av[i + 1], 1024);
			lsn_string[1024 - 1] = '\0';
			sscanf(lsn_string, "%llu", &txnid);
			printf("LSN to start data capture(%llu)\n", txnid);
			
			//sscanf(lsn_string, "%d:%x", &lsn1, &lsn2);
			//lsn = ((((bigint)lsn1 << 32)) | (bigint)lsn2);
			//printf("LSN to start data capture(%d:0x%x)\n",lsn1, lsn2);
			
			GOBBLE_ARG;
		} */
		else if (strcmp(av[i], "-M") == 0)
		{
			CHECK_FOR_REQUIRED_ARG;
			char *endptr;
			max_ops = strtol(av[i + 1], &endptr, 0);
			if (endptr && endptr[0] != '\0' && !isspace(endptr[0]))
			{
				fprintf(stderr, "Invalid data entered for -M option %s\n", endptr);
				exit(-1);
			}
			GOBBLE_ARG;
		}
		/*else if (strcmp(av[i], "-n") == 0)
		{
			nodebug = 1;
			GOBBLE_ARG;
		}*/
		else if (strcmp(av[i], "-J") == 0)
		{
			CHECK_FOR_REQUIRED_ARG;
			//sscanf(av[i + 1], "%d", &join);
			//datafile[NAMELEN - 1] = '\0';
			char *endptr;
			join = strtol(av[i + 1], &endptr, 0);
			if (endptr && endptr[0] != '\0' && !isspace(endptr[0]))
			{
				fprintf(stderr, "Invalid data enetered for timeout -Timeout option %s\n", endptr);
				exit(-1);
			}
			GOBBLE_ARG;
		}
		else if (strcmp(av[i], "-P") == 0)
		{
			detach = 1;
		}
		else if (strcmp(av[i], "-C") == 0)
		{
			delete = 1;
		}
		else if (strcmp(av[i], "-h") == 0 ||
			strcmp(av[i], "?") == 0)
		{
			Usage(av[0]);
		}
		else
		{
			printf("Not supported options are detected, for more information run \"%s -h\"", av[0]);
			exit(-1);
		}
		i++;
	}
}

// This should not be called when "join" value is specified. This means, previous session is being attached, hence
// this thread function must not be invoked.
DWORD WINAPI ThreadRegisterPushDataQuery(LPVOID lpParam)
{
	SQLHSTMT        hstmt;
	SQLRETURN       rc = 0;
	
	//SQLINTEGER threadCounter = *((int *)lpParam);
	struct InputData inValues = *((struct InputData *)lpParam);
	SQLCHAR inputBuff[SQL_QUERY_LENGTH + (DB_OBJECT_LENGTH)*5 + 15 + 5 + 1];
	SQLCHAR registerParams[256];
	SQLCHAR temp[30];
	BOOL addComma = FALSE;

	SQLCHAR retvalStr[51] = { 0 };
	SQLINTEGER lo_size = JSON_DATA_LEN + 1;
	SQLCHAR lo_data[JSON_DATA_LEN + 1];
	SQLLEN lo_data_valsize = 0;
	FILE        *outfilefp = NULL;
	SQLINTEGER  dataWritten = 0;
	SQLCHAR fileName[512 + 1 + DB_OBJECT_LENGTH + 1 + 3 + 5 + 1]; // sprintf(fileName, "%s_%s_%d.data", outfile, inValues.tableName, inValues.myCount);

	memset(inputBuff, 0, sizeof(inputBuff));
	memset(registerParams, 0, sizeof(registerParams));
	memset(fileName, 0, sizeof(fileName));
	
	if (outfile[0] != '\0')
	{
		sprintf(fileName, "%s_%s_%d.data", outfile, inValues.tableName, inValues.myCount);
		outfilefp = fopen(fileName, "w+");
		if (!outfilefp)
		{
			printf("File open failed for %s\n", fileName);
			exit(-1);
		}
	}

	/* Allocate the statement handle */
	rc = SQLAllocHandle(SQL_HANDLE_STMT, hdbc, &hstmt);
	if (checkError(rc, SQL_HANDLE_DBC, hdbc, (SQLCHAR *) "Error in Step 1 -- Statement Handle Allocation failed\nExiting!!"))
		return (1);
	
	if ( (max_ops > 0) || (timeout != 300 && timeout > 0) || (max_recs_per_read > 1) )
	{
		strcpy(registerParams, "execute function sysadmin:informix.task('pushdata register', '{");
		if (max_ops > 0)
		{
			memset(temp, 0, sizeof(temp));
			sprintf(temp, "max_pending_ops:\"%d\"", max_ops);
			strcat(registerParams, temp);
			addComma = TRUE;
		}
		if ( (timeout != 300 && timeout > 0) || (timeout == 300) )
		{
			memset(temp, 0, sizeof(temp));
			if(addComma)
				sprintf(temp, ",timeout:\"%d\"", timeout);
			else
				sprintf(temp, "timeout:\"%d\"", timeout);
			strcat(registerParams, temp);
			addComma = TRUE;
		}
		if ( (max_recs_per_read > 1) || (max_recs_per_read == 1) )
		{
			memset(temp, 0, sizeof(temp));
			if (addComma)
				sprintf(temp, ",maxrecs:\"%d\"", max_recs_per_read);
			else
				sprintf(temp, "maxrecs:\"%d\"", max_recs_per_read);
			strcat(registerParams, temp);
			addComma = TRUE;
		}
		strcat(registerParams, "}')");
	}
	else //Default params
	{
		sprintf(registerParams, "execute function sysadmin:informix.task('pushdata register', '{timeout:\"300\",maxrecs:\"1\"}')");
	}
	//sprintf(registerParams, "execute function sysadmin:informix.task('pushdata register', '{timeout:\"%d\",maxrec:\"%d\",txnid:\"%llu\",max_pending_ops:\"%d\"}')", inValues.tableName, inValues.ownerName, inValues.dbName, inValues.sqlQuery);
	//printf("\nRegister params = %s\n", registerParams);
	rc = SQLExecDirect(hstmt, registerParams, SQL_NTS);
	if (checkError(rc, SQL_HANDLE_STMT, hstmt, (SQLCHAR *) "Error in Step 2 -- SQLExecDirect failed\n"))
		goto Exit;

	rc = SQLFetch(hstmt);
	if (checkError(rc, SQL_HANDLE_STMT, hstmt, (SQLCHAR *) "Error in Step 3 -- SQLFetch failed\n"))
		goto Exit;

	memset(retvalStr, 0, sizeof(retvalStr));
	rc = SQLGetData(hstmt, 1, SQL_C_CHAR, retvalStr, 50, NULL);
	if (checkError(rc, SQL_HANDLE_STMT, hstmt, (SQLCHAR *) "Error in Step 4 -- SQLGetData failed\n"))
		goto Exit;

	if (strcmp(retvalStr, "OK") != 0)
	{
		printf("Pushdata register for \'maxrecs\' and \'timeout\' not successful - Exiting\n");
		goto Exit;
	}

	rc = SQLCloseCursor(hstmt);
	if (checkError(rc, SQL_HANDLE_STMT, hstmt, (SQLCHAR *) "Error in Step 5 -- SQLCloseCursor failed\n"))
		goto Exit;

	if (lableCounter > 0)
		sprintf(inputBuff, "execute function sysadmin:informix.task('pushdata register', '{table:\"%s\",label:\"%s\",owner:\"%s\",database:\"%s\",query:\"%s\"}')", inValues.tableName, inValues.pdLable, inValues.ownerName, inValues.dbName, inValues.sqlQuery);
	else
		sprintf(inputBuff, "execute function sysadmin:informix.task('pushdata register', '{table:\"%s\",owner:\"%s\",database:\"%s\",query:\"%s\"}')", inValues.tableName, inValues.ownerName, inValues.dbName, inValues.sqlQuery);
	//printf("Input query : %s\n", inputBuff);
	//rc = SQLExecDirect(hstmt, "execute function sysadmin:informix.task('pushdata register', '{table:\"tab2\",owner:\"informix\",database:\"sheshdb\",query:\"select * from tab2;\"}')", SQL_NTS);
	rc = SQLExecDirect(hstmt, inputBuff, SQL_NTS);
	if (checkError(rc, SQL_HANDLE_STMT, hstmt, (SQLCHAR *) "Error in Step 6 -- SQLExecDirect failed\n"))
		goto Exit;

	rc = SQLFetch(hstmt);
	if (checkError(rc, SQL_HANDLE_STMT, hstmt, (SQLCHAR *) "Error in Step 7 -- SQLFetch failed\n"))
		goto Exit;

	memset(retvalStr, 0, sizeof(retvalStr));
	rc = SQLGetData(hstmt, 1, SQL_C_CHAR, retvalStr, 50, NULL);
	if (checkError(rc, SQL_HANDLE_STMT, hstmt, (SQLCHAR *) "Error in Step 8 -- SQLGetData failed\n"))
		goto Exit;

	//printf("Pushdata register for SQL query : %s\n", retvalStr);
	if (strcmp(retvalStr, "OK") != 0)
	{
		printf("Pushdata register for SQL query not successful - Exiting\n");
		goto Exit;
	}
	rc = SQLCloseCursor(hstmt);
	if (checkError(rc, SQL_HANDLE_STMT, hstmt, (SQLCHAR *) "Error in Step 9 -- SQLCloseCursor failed\n"))
		goto Exit;

	while (TRUE)
	{
		printf("Waiting for pushdata retrieval...\n");
		//printf("Session ID inside WHILE loop %d\n", sesID);
		/* Allocate a buffer to hold the smart large object’s data chunks */
		memset(lo_data, 0, lo_size);
	    /* Read the smart large object’s data */
		rc = SQLBindParameter(hstmt, 1, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER, (UDWORD)0, 0, &sesID, sizeof(sesID), NULL);
		if (checkError(rc, SQL_HANDLE_STMT, hstmt, "Error in Step 10 -- SQLBindParameter failed(param 1)\n"))
			goto Exit;

		rc = SQLBindParameter(hstmt, 2, SQL_PARAM_OUTPUT, SQL_C_CHAR, SQL_CHAR, lo_size, 0, lo_data, lo_size, &lo_data_valsize);
		if (checkError(rc, SQL_HANDLE_STMT, hstmt, "Error in Step 11 -- SQLBindParameter failed(param 2)\n"))
			goto Exit;

		rc = SQLExecDirect(hstmt, "{call ifx_lo_read(?, ?)}", SQL_NTS);
		if (checkError(rc, SQL_HANDLE_STMT, hstmt, "Error in Step 12 -- SQLExecDirect failed\n"))
			goto Exit;

		if (lo_data_valsize > 0)
		{
			/* Null-terminate the last byte of the smart large objects data */
			lo_data[lo_data_valsize] = 0;
			/* Print the contents of the smart large object */
			if(showData == 1)
			{ 
				printf("Push Data JSON : \n\n%s\n\n", lo_data);
			}
			if (strncmp(lo_data, "{\"ifx_isTimeout\":\"true\"}", 24) == 0)
			{
				printf("\n Timeout occurred\n");
				goto TimeOut_Occurred;
			}
			if (outfilefp != NULL)
			{
				dataWritten = fwrite(lo_data, 1, lo_data_valsize, outfilefp);
				if (dataWritten != lo_data_valsize)
				{
					printf("Data written into the file failed. Exiting....\n");
					rc = -1;
					goto Exit;
				}
				fflush(outfilefp);
			}
		}
	}

TimeOut_Occurred:
	rc = SQLCloseCursor(hstmt);
	if (checkError(rc, SQL_HANDLE_STMT, hstmt, (SQLCHAR *) "Error in Step 13 -- SQLCloseCursor failed\n"))
		goto Exit;

	if (!detach)
	{
		if (lableCounter > 0)
			sprintf(inputBuff, "execute function sysadmin:informix.task('pushdata deregister', '{table:\"%s\",lable:\"$s\",owner:\"%s\",database:\"%s\",query:\"%s\"}')", inValues.tableName, inValues.pdLable, inValues.ownerName, inValues.dbName, inValues.sqlQuery);
		else
			sprintf(inputBuff, "execute function sysadmin:informix.task('pushdata deregister', '{table:\"%s\",owner:\"%s\",database:\"%s\",query:\"%s\"}')", inValues.tableName, inValues.ownerName, inValues.dbName, inValues.sqlQuery);
		rc = SQLExecDirect(hstmt, inputBuff, SQL_NTS);
		if (checkError(rc, SQL_HANDLE_STMT, hstmt, (SQLCHAR *) "Error in Step 14 -- SQLExecDirect failed\n"))
			goto Exit;

		rc = SQLCloseCursor(hstmt);
		if (checkError(rc, SQL_HANDLE_STMT, hstmt, (SQLCHAR *) "Error in Step 15 -- SQLCloseCursor failed\n"))
			goto Exit;
	}

Exit:

	/* CLEANUP: Close the statement handle/file pointer
	**          Free the statement handle
	**          Exit
	*/

	if (outfilefp != NULL)
	{
		fclose(outfilefp);
	}
	
	/* Close the statement handle */
	SQLFreeStmt(hstmt, SQL_CLOSE);

	/* Free the statement handle */
	SQLFreeHandle(SQL_HANDLE_STMT, hstmt);

	return (rc);
}

int main (long         argc,
          char*        argv[])
{
    SQLHSTMT        hstmt;
    /* Miscellaneous variables */

	SQLCHAR         dsn[NAMELEN + 1] = { 0 };   /*name of the DSN used for connecting to the database*/
    SQLRETURN       rc = 0;
    SQLINTEGER		i = 0;

    SQLCHAR         connStrIn[NAMELEN];
    SQLCHAR         connStrOut[NAMELEN];
    SQLSMALLINT     connStrOutLen;

	SQLCHAR sessionID[129] = { 0 };
	SQLCHAR pusDataRegisterBuff[200] = { 0 };
	
	SQLINTEGER stackSize = 40 * 1024;
	HANDLE hThread_[MAXTAB];
	DWORD threadID_[MAXTAB];

	SQLINTEGER lo_size = JSON_DATA_LEN + 1;
	SQLCHAR lo_data[JSON_DATA_LEN + 1];
	SQLLEN lo_data_valsize = 0;
	FILE        *outfilefp = NULL;
	SQLINTEGER  dataWritten = 0;
	SQLCHAR fileName[512 + 1 + DB_OBJECT_LENGTH + 1 + 3 + 5 + 1];
	SQLCHAR *tmpTok = NULL;

	memset(&inputValues, 0, sizeof(struct InputData)*MAXTAB);
	memset(outfile, 0, sizeof(outfile));
	memset(dsnName, 0, sizeof(dsnName));

	ProcessOption((int)argc, argv);
	if (lableCounter > 0)
	{
		if (lableCounter != tableCounter)
		{
			printf("\nNumber of lables and tables do not match in the input provided.\n");
			exit(0);
		}
	}
	if ( ((tableCounter != ownerCounter) && (tableCounter != selectCounter) && (tableCounter != dbCounter) && 
	    (ownerCounter != dbCounter) && (ownerCounter != selectCounter) &&
		(selectCounter != dbCounter)) && (join > 0))
	{
		printf("Mandatory combination, Database(%d), Table(%d), Owner(%d) and Select statement(%d) counts are not matching, recheck provided options and try again.", dbCounter, tableCounter, ownerCounter, selectCounter);
		exit(0);
	}

	if ((tableCounter > 0 || ownerCounter > 0 || selectCounter > 0 || dbCounter > 0 || 
		 (timeout > 0 && timeout != 300) || max_recs_per_read > 1 || max_ops > 0) && (join > 0))
	{
		printf("\nWith -J option, only -C, -F, -DSN & -Show options are allowed. Refer \"%s -h\" to get more information.\n", argv[0]);
		exit(0);
	}
	if (showData == 1)
	{
		for (i = 0; i < tableCounter; i++)
		{
			printf("Set %d details :\n", i + 1);
			printf("\tDatabase\t: %s\n", inputValues[i].dbName);
			printf("\tTable\t\t: %s\n", inputValues[i].tableName);
			printf("\tOwner\t\t: %s\n", inputValues[i].ownerName);
			printf("\tSelect Query\t: %s\n", inputValues[i].sqlQuery);
		}
	}
    /*          Get data source name from command line (or use default)
    **          Allocate the environment handle and set ODBC version
    **          Allocate the connection handle
    **          Establish the database connection
    **          Allocate the statement handle
    */

    /* If(dsn is not explicitly passed in as arg) */
	if(dsnName[0] == '\0')
    {
        /* Use default dsn - SmartTrigger */
        fprintf (stdout, "\nUsing default DSN : %s\n", defDsn);
        strncpy ((char *)dsn, (char *)defDsn, NAMELEN);
    }
    else
    {
        // Use specified dsn
        strncpy ((char *)dsn, (char *)dsnName, NAMELEN);
        fprintf (stdout, "\nUsing specified DSN : %s\n", dsn);
    }


    /* Allocate the Environment handle */
    rc = SQLAllocHandle (SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv);
    if (rc != SQL_SUCCESS)
    {
        fprintf (stdout, "Environment Handle Allocation failed\nExiting!!");
        return (1);
    }


    /* Set the ODBC version to 3.0 */
    rc = SQLSetEnvAttr (henv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER) SQL_OV_ODBC3, 0);
    if (checkError (rc, SQL_HANDLE_ENV, henv, (SQLCHAR *) "Error(main) in Step 1 -- SQLSetEnvAttr failed\nExiting!!"))
        return (1);


    /* Allocate the connection handle */
    rc = SQLAllocHandle (SQL_HANDLE_DBC, henv, &hdbc);
    if (checkError (rc, SQL_HANDLE_ENV, henv, (SQLCHAR *) "Error(main) in Step 2 -- Connection Handle Allocation failed\nExiting!!"))
        return (1);


    /* Establish the database connection */
    sprintf((char *) connStrIn, "DSN=%s", dsn);

    rc = SQLDriverConnect (hdbc, NULL, connStrIn, SQL_NTS, connStrOut, NAMELEN, &connStrOutLen, SQL_DRIVER_NOPROMPT);
    if (checkError (rc, SQL_HANDLE_DBC, hdbc, (SQLCHAR *) "Error(main) in Step 3 -- SQLDriverConnect failed\nExiting!!"))
        return (1);


    /* Allocate the statement handle */
    rc = SQLAllocHandle (SQL_HANDLE_STMT, hdbc, &hstmt );
    if (checkError (rc, SQL_HANDLE_DBC, hdbc, (SQLCHAR *) "Error(main) in Step 4 -- Statement Handle Allocation failed\nExiting!!"))
        return (1);

    //fprintf (stdout, "STEP 1 done...connected to database server\n");
  
	if (join == 0)
	{
		rc = SQLExecDirect(hstmt, "execute function sysadmin:informix.task('pushdata open')", SQL_NTS);
		if (checkError(rc, SQL_HANDLE_STMT, hstmt, (SQLCHAR *) "Error(main) in Step 5 -- SQLExecDirect failed\n"))
			goto Exit;
	}
	else // Open session with user provided session ID.
	{
		sprintf(pusDataRegisterBuff, "execute function sysadmin:informix.task('pushdata join', '{session_id:\"%d\"}')", join);
		printf("\n Join session query : %s\n", pusDataRegisterBuff);
		rc = SQLExecDirect(hstmt, pusDataRegisterBuff, SQL_NTS);
		if (checkError(rc, SQL_HANDLE_STMT, hstmt, (SQLCHAR *) "Error(main) in Step 6 -- SQLExecDirect failed\n"))
			goto Exit;
	}

	rc = SQLFetch(hstmt);
	if (checkError(rc, SQL_HANDLE_STMT, hstmt, (SQLCHAR *) "Error(main) in Step 7 -- SQLFetch failed\n"))
		goto Exit;

	rc = SQLGetData(hstmt, 1, SQL_C_CHAR, sessionID, 128, NULL);
	if (checkError(rc, SQL_HANDLE_STMT, hstmt, (SQLCHAR *) "Error(main) in Step 8 --  SQLGetData failed\n"))
		goto Exit;

	printf("Pushdata session ID : %s\n", sessionID);
	sesID = atoi(sessionID);
	printf("Pushdata session ID integer : %d\n", sesID);

	rc = SQLCloseCursor(hstmt);
	if (checkError(rc, SQL_HANDLE_STMT, hstmt, (SQLCHAR *) "Error(main) in Step 9 -- SQLCloseCursor failed\n"))
		goto Exit;

	if (detach)
	{
		memset(sessionID, 0, sizeof(sessionID));

		rc = SQLExecDirect(hstmt, "execute function sysadmin:informix.task('pushdata setdetach')", SQL_NTS);
		if (checkError(rc, SQL_HANDLE_STMT, hstmt, (SQLCHAR *) "Error(main) in Step 10 -- SQLExecDirect failed\n"))
			goto Exit;

		rc = SQLFetch(hstmt);
		if (checkError(rc, SQL_HANDLE_STMT, hstmt, (SQLCHAR *) "Error(main) in Step 11 -- SQLFetch failed\n"))
			goto Exit;

		rc = SQLGetData(hstmt, 1, SQL_C_CHAR, sessionID, 128, NULL);
		if (checkError(rc, SQL_HANDLE_STMT, hstmt, (SQLCHAR *) "Error(main) in Step 12 --  SQLGetData failed\n"))
			goto Exit;

		printf("Pushdata client session unique ID : %s\n", sessionID);
		
		rc = SQLCloseCursor(hstmt);
		if (checkError(rc, SQL_HANDLE_STMT, hstmt, (SQLCHAR *) "Error(main) in Step 13 -- SQLCloseCursor failed\n"))
			goto Exit;
	}

	for (i = 0; i < tableCounter; ++i)
	{
		printf("Start Thread %d\n", i + 1);
		hThread_[i] = CreateThread(
			0, // Security Attributes (no security restrictions)
			stackSize, // Stack Size
			ThreadRegisterPushDataQuery, // Start address
			(void *)&inputValues[i],
			0, // Creation Flags (create running)
			&(threadID_[i]) // Thread Id
		);
		if (0 == hThread_[i]) 
		{
			switch (errno) 
			{
			case 11:
				printf("??? Thread %d error: EAGAIN ???\n", i);
				break;
			case 22:
				printf("??? Thread %d error: Invalid Arguments ???\n", i);
				break;
			default:
				printf("??? Thread %d error: Unrecognized Error ???\n", i);
				break;
			}
		}
	}

	if(tableCounter > 0)
		WaitForMultipleObjects(tableCounter, hThread_, TRUE, INFINITE);

	for (i = 0; i < tableCounter; ++i)
	{
		printf("Close Thread Handle : %d\n", i);
		CloseHandle(hThread_[i]);
	}
	
	if (join != 0)
	{
		if (outfile[0] != '\0')
		{
			sprintf(fileName, "%s.data", outfile);
			outfilefp = fopen(fileName, "w+");
			if (!outfilefp)
			{
				printf("File open failed for %s\n", fileName);
				exit(-1);
			}
		}

		while (TRUE)
		{
			printf("Waiting for pushdata retrieval...\n");
			//printf("Session ID inside WHILE loop %d\n", sesID);
			/* Allocate a buffer to hold the smart large object’s data chunks */
			memset(lo_data, 0, lo_size);
			/* Read the smart large object’s data */
			rc = SQLBindParameter(hstmt, 1, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER, (UDWORD)0, 0, &sesID, sizeof(sesID), NULL);
			if (checkError(rc, SQL_HANDLE_STMT, hstmt, "Error in Step 14 -- SQLBindParameter failed(param 1)\n"))
				goto Exit;

			rc = SQLBindParameter(hstmt, 2, SQL_PARAM_OUTPUT, SQL_C_CHAR, SQL_CHAR, lo_size, 0, lo_data, lo_size, &lo_data_valsize);
			if (checkError(rc, SQL_HANDLE_STMT, hstmt, "Error in Step 15 -- SQLBindParameter failed(param 2)\n"))
				goto Exit;

			rc = SQLExecDirect(hstmt, "{call ifx_lo_read(?, ?)}", SQL_NTS);
			if (checkError(rc, SQL_HANDLE_STMT, hstmt, "Error in Step 16 -- SQLExecDirect failed\n"))
				goto Exit;

			if (lo_data_valsize > 0)
			{
				/* Null-terminate the last byte of the smart large objects data */
				lo_data[lo_data_valsize] = 0;
				/* Print the contents of the smart large object */
				if (showData == 1)
				{
					printf("Push Data JSON : \n\n%s\n\n", lo_data);
				}
				if (strncmp(lo_data, "{\"ifx_isTimeout\":\"true\"}", 24) == 0)
				{
					printf("\n Timeout occurred\n");
					goto TimeOut_Occurred;
				}
				if (outfilefp != NULL)
				{
					dataWritten = fwrite(lo_data, 1, lo_data_valsize, outfilefp);
					if (dataWritten != lo_data_valsize)
					{
						printf("Data written into the file failed. Exiting....\n");
						rc = -1;
						goto Exit;
					}
					fflush(outfilefp);
				}
			}
		}
	}
TimeOut_Occurred:
	if (delete)
	{
		/* memset(pusDataRegisterBuff, 0, sizeof(pusDataRegisterBuff));
		if (join)
		{
			sprintf(pusDataRegisterBuff, "execute function sysadmin:informix.task('pushdata delete', '{session_id:\"%d\"}')", join);
		}
		else 
		{
			sprintf(pusDataRegisterBuff, "execute function sysadmin:informix.task('pushdata delete', '{delete_all:\"1\"}')");
		} 
		rc = SQLExecDirect(hstmt, pusDataRegisterBuff, SQL_NTS);
		*/
		rc = SQLExecDirect(hstmt, "execute function sysadmin:informix.task('pushdata delete')", SQL_NTS);
		if (checkError(rc, SQL_HANDLE_STMT, hstmt, (SQLCHAR *) "Error in Step 17 -- SQLExecDirect failed\n"))
			goto Exit;
	}

Exit:

    /* CLEANUP: Close the statement handle
    **          Free the statement handle
    **          Disconnect from the datasource
    **          Free the connection and environment handles
    **          Exit
    */

	if (outfilefp != NULL)
	{
		fclose(outfilefp);
	}

    /* Close the statement handle */
    SQLFreeStmt (hstmt, SQL_CLOSE);

    /* Free the statement handle */
    SQLFreeHandle (SQL_HANDLE_STMT, hstmt);

    /* Disconnect from the data source */
    SQLDisconnect (hdbc);

    /* Free the environment handle and the database connection handle */
    SQLFreeHandle (SQL_HANDLE_DBC, hdbc);
    SQLFreeHandle (SQL_HANDLE_ENV, henv);

    return (rc);
}