/*
 * This function changes the size of a block of memory that was previously allocated with malloc().
 */
void * GMM001_realloc (uint32_t size, void * MemPtr)
{
  void * MemPtr1 = NULL;
  FUNCTION_ENTRY(GID_GMM001, (uint32_t)GMM001_FUNCTION_ENTRY);

/*<<<DD_GMM001_API_3_1>>>*/   
  if (((uint32_t)MemPtr >= (uint32_t)Heap_Bank1_Start) && ((uint32_t)MemPtr <= ((uint32_t)Heap_Bank1_Start + LENGTH1)))
  {
	  MemPtr1 = LMM001_realloc(&GMM001_handle0, MemPtr, size);
  }

/*<<<DD_GMM001_API_3_2>>>*/   
  else if (((uint32_t)MemPtr >= (uint32_t)Heap_Bank2_Start) && ((uint32_t)MemPtr <= ((uint32_t)Heap_Bank2_Start + LENGTH2)))
  {
 	  MemPtr1 = LMM001_realloc(&GMM001_handle1, MemPtr, size);
  }

/*<<<DD_GMM001_API_3_3>>>*/   
  else if (((uint32_t)MemPtr >= (uint32_t)Heap_Bank3_Start) && ((uint32_t)MemPtr <= ((uint32_t)Heap_Bank3_Start + LENGTH3)))
  {
 	  MemPtr1 = LMM001_realloc(&GMM001_handle2, MemPtr, size);
  }
  FUNCTION_EXIT(GID_GMM001, (uint32_t)GMM001_FUNCTION_EXIT);
  return MemPtr1;
}

u32
acpi_ns_get_pathname_length (
	acpi_namespace_node     *node)
{
	u32                     size;
	acpi_namespace_node     *next_node;


	FUNCTION_ENTRY ();


	/*
	 * Compute length of pathname as 5 * number of name segments.
	 * Go back up the parent tree to the root
	 */
	for (size = 0, next_node = node;
		  acpi_ns_get_parent_object (next_node);
		  next_node = acpi_ns_get_parent_object (next_node)) {
		size += PATH_SEGMENT_LENGTH;
	}

	/* Special case for size still 0 - no parent for "special" nodes */

	if (!size) {
		size = PATH_SEGMENT_LENGTH;
	}

	return (size + 1);
}

acpi_namespace_node *
acpi_ns_map_handle_to_node (
	acpi_handle             handle)
{

	FUNCTION_ENTRY ();


	/*
	 * Simple implementation for now;
	 * TBD: [Future] Real integer handles allow for more verification
	 * and keep all pointers within this subsystem!
	 */
	if (!handle) {
		return (NULL);
	}

	if (handle == ACPI_ROOT_OBJECT) {
		return (acpi_gbl_root_node);
	}


	/* We can at least attempt to verify the handle */

	if (!VALID_DESCRIPTOR_TYPE (handle, ACPI_DESC_TYPE_NAMED)) {
		return (NULL);
	}

	return ((acpi_namespace_node *) handle);
}

void
acpi_rs_dump_io (
	acpi_resource_data      *data)
{
	acpi_resource_io        *io_data = (acpi_resource_io *) data;


	FUNCTION_ENTRY ();


	acpi_os_printf ("Io Resource\n");

	acpi_os_printf ("  %d bit decode\n",
			 DECODE_16 == io_data->io_decode ? 16 : 10);

	acpi_os_printf ("  Range minimum base: %08X\n",
			 io_data->min_base_address);

	acpi_os_printf ("  Range maximum base: %08X\n",
			 io_data->max_base_address);

	acpi_os_printf ("  Alignment: %08X\n",
			 io_data->alignment);

	acpi_os_printf ("  Range Length: %08X\n",
			 io_data->range_length);

	return;
}

void
acpi_rs_dump_fixed_memory32 (
	acpi_resource_data          *data)
{
	acpi_resource_fixed_mem32   *fixed_memory32_data = (acpi_resource_fixed_mem32 *) data;


	FUNCTION_ENTRY ();


	acpi_os_printf ("32-Bit Fixed Location Memory Range Resource\n");

	acpi_os_printf ("  Read%s\n",
			 READ_WRITE_MEMORY ==
			 fixed_memory32_data->read_write_attribute ?
			 "/Write" : " Only");

	acpi_os_printf ("  Range base address: %08X\n",
			 fixed_memory32_data->range_base_address);

	acpi_os_printf ("  Range length: %08X\n",
			 fixed_memory32_data->range_length);

	return;
}

GtkMngView *
gtk_mng_view_new (void)
{
    FUNCTION_ENTRY();
    FUNCTION_EXIT();
  return GTK_MNG_VIEW (g_object_new(GTK_MNG_VIEW_TYPE, NULL));
}

UINT32
AcpiNsGetPathnameLength (
    ACPI_NAMESPACE_NODE     *Node)
{
    UINT32                  Size;
    ACPI_NAMESPACE_NODE     *NextNode;


    FUNCTION_ENTRY ();


    /*
     * Compute length of pathname as 5 * number of name segments.
     * Go back up the parent tree to the root
     */
    for (Size = 0, NextNode = Node;
          AcpiNsGetParentObject (NextNode);
          NextNode = AcpiNsGetParentObject (NextNode))
    {
        Size += PATH_SEGMENT_LENGTH;
    }

    /* Special case for size still 0 - no parent for "special" nodes */

    if (!Size)
    {
        Size = PATH_SEGMENT_LENGTH;
    }

    return (Size + 1);
}

	void DataPointObserver::processDataPointUpdate( unsigned long pkey, 
		boost::shared_ptr<TA_Base_Bus::DpDynamicSyncUpdate> updateDetails )
	{
		//
		// callback from one of the DataPoint supposedly being assigned to this observer
		//
		std::stringstream ss;
		ss << "processDataPointUpdate: Observer ID "  
		   << m_observerID << "--> received an update from data point " << pkey;
		FUNCTION_ENTRY (ss.str().c_str() );


		// only proceed if the specified pkey matches with the pkey of the
		// data point assigned to this observer
		DataPoint * existingDataPoint = 0;
		existingDataPoint = findExistingDataPoint ( pkey );

		// if found one
		if ( NULL != existingDataPoint )
		{
			//convet it from cpp to corba first.
			TA_Base_Bus::DataPointCorbaTypes::UDynamicSyncUpdate dpUpdate;

			convertDynamicSyncUpdate(*updateDetails, dpUpdate);

			saveDataPointUpdateDetails ( pkey, dpUpdate );
		}
		// else do nothing

		FUNCTION_EXIT;
	}

u32
acpi_tb_get_table_count (
	RSDP_DESCRIPTOR         *RSDP,
	acpi_table_header       *RSDT)
{
	u32                     pointer_size;


	FUNCTION_ENTRY ();


#ifndef _IA64

	if (RSDP->revision < 2) {
		pointer_size = sizeof (u32);
	}

	else
#endif
	{
		pointer_size = sizeof (u64);
	}

	/*
	 * Determine the number of tables pointed to by the RSDT/XSDT.
	 * This is defined by the ACPI Specification to be the number of
	 * pointers contained within the RSDT/XSDT.  The size of the pointers
	 * is architecture-dependent.
	 */
	return ((RSDT->length - sizeof (acpi_table_header)) / pointer_size);
}

SQLRETURN SRVR_STMT_HDL::Prepare(const SQLValue_def *inSqlString, short inStmtType, short inHoldability,
								 long inQueryTimeout,bool isISUD)
{
	FUNCTION_ENTRY("SRVR_STMT_HDL::Prepare",(""));
	DEBUG_OUT(DEBUG_LEVEL_ENTRY,("  inSqlString='%s'",
		CLI_SQL_VALUE_STR(inSqlString)));
	DEBUG_OUT(DEBUG_LEVEL_ENTRY,("  inStmtType=%s, inHoldability=%d, inQueryTimeout=%ld, isISUD=%d",
		CliDebugStatementType(inStmtType),
		inHoldability,
		inQueryTimeout,isISUD));

	SQLRETURN rc;
	size_t	len;
	this->isISUD = isISUD;
	if (isReadFromModule)	// Already SMD label is found
		CLI_DEBUG_RETURN_SQL(SQL_SUCCESS);
	// cleanup all memory allocated in the previous operations
	cleanupAll();
	sqlString.dataCharset = inSqlString->dataCharset;
	sqlString.dataType = inSqlString->dataType;
	MEMORY_ALLOC_ARRAY(sqlString.dataValue._buffer,unsigned char,inSqlString->dataValue._length+1);
	sqlString.dataValue._length = inSqlString->dataValue._length+1;

	strncpy((char *)sqlString.dataValue._buffer, (const char *)inSqlString->dataValue._buffer, inSqlString->dataValue._length);
	sqlString.dataValue._buffer[inSqlString->dataValue._length] = '\0';
	stmtType = inStmtType;
	holdability = inHoldability;

	CLI_DEBUG_RETURN_SQL(PREPARE(this));
}

    void DatabaseFactory::delDatabase( IDatabase* pDatabase )
    {
        FUNCTION_ENTRY("delDatabase(IDatabase*)");

        if ( NULL == pDatabase )
        {
            LOG(SourceInfo, DebugUtil::GenericLog, DebugUtil::DebugWarn, "Invalid input parameter that IDatabase is NULL pointer");
            return;
        }

        bool bExist = false;

        {
            ThreadGuard guard( m_getDatabaseLock );

            // set up iterators to step through the database map.
            ThreadMap::iterator threadIter (m_databaseMap.begin());
            ThreadMap::iterator threadIterEnd (m_databaseMap.end());

            // step through member map
            while (threadIter != threadIterEnd)
            {
                ConnectionMap::iterator iter (threadIter->second.begin());
                ConnectionMap::iterator iterEnd (threadIter->second.end());
                while (iter != iterEnd)
                {
                    if (iter->second == pDatabase)
                    {
                        threadIter->second.erase( iter );
                        if ( threadIter->second.empty() )
                        {
                            m_databaseMap.erase( threadIter );
                        }
                        bExist = true;
                        break;
                    }               
                    iter++;
                }

                if ( bExist )
                {
                    break;
                }

                threadIter++;
            }
        }

        if ( bExist )
        {
            delete pDatabase;
            pDatabase = NULL;
        }
        else
        {
            TA_THROW(DatabaseException("Unable to find the IDatabase"));
        }

        FUNCTION_EXIT;
    }

//venu changed dialogueId and stmtId from int to long for 64 bit
JNIEXPORT void JNICALL Java_org_trafodion_jdbc_t2_SQLMXStatement_cancel
(JNIEnv *jenv, jobject jobj, jstring server, jlong dialogueId, jlong stmtId)
{
    FUNCTION_ENTRY("Java_org_trafodion_jdbc_t2_SQLMXStatement_cancel",("..."));

    ExceptionStruct				exception_;
    ERROR_DESC_LIST_def			sqlWarning;

    odbc_SQLSvc_CancelStatement_sme_(NULL, NULL, &exception_,
                                     dialogueId,
                                     stmtId,
                                     &sqlWarning);

    // Ignore setting warning since the input is jclass and not jobject
    switch (exception_.exception_nr)
    {
    case CEE_SUCCESS:
        break;
    case odbc_SQLSvc_CancelStatement_SQLError_exn_:
        throwSQLException(jenv, &exception_.u.SQLError);
        break;
    case odbc_SQLSvc_CancelStatement_ParamError_exn_:
        throwSQLException(jenv, PROGRAMMING_ERROR, exception_.u.ParamError.ParamDesc, "HY000");
        break;
    case odbc_SQLSvc_CancelStatement_SQLInvalidHandle_exn_:
        throwSQLException(jenv, INVALID_HANDLE_ERROR, NULL, "HY000", exception_.u.SQLInvalidHandle.sqlcode);
        break;
    case odbc_SQLSvc_CancelStatement_InvalidConnection_exn_:
    default:
        // TFDS - This exceptions should not happen
        throwSQLException(jenv, PROGRAMMING_ERROR, NULL, "HY000", exception_.exception_nr);
        break;
    }
    FUNCTION_RETURN_VOID((NULL));
}

static void
gtk_mng_view_realize (GtkWidget * widget)
{
    FUNCTION_ENTRY();
  GdkWindowAttr attributes;
  gint attributes_mask;

  g_return_if_fail (IS_GTK_MNG_VIEW (widget));

  GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);

  attributes.window_type = GDK_WINDOW_CHILD;
  attributes.x = widget->allocation.x;
  attributes.y = widget->allocation.y;
  attributes.width = widget->allocation.width;
  attributes.height = widget->allocation.height;
  attributes.wclass = GDK_INPUT_OUTPUT;
  attributes.visual = gtk_widget_get_visual (widget);
  attributes.colormap = gtk_widget_get_colormap (widget);
  attributes.event_mask = gtk_widget_get_events (widget);
  attributes.event_mask |= GDK_EXPOSURE_MASK;
  attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
  widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
			    	   &attributes, attributes_mask);
  gdk_window_set_user_data (widget->window, widget);
  widget->style = gtk_style_attach (widget->style, widget->window);
  gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
}

void
AcpiHwDisableGpe (
    UINT32                  GpeNumber)
{
    UINT32                  InByte;
    UINT32                  RegisterIndex;
    UINT32                  BitMask;


    FUNCTION_ENTRY ();


    /*
     * Translate GPE number to index into global registers array.
     */
    RegisterIndex = AcpiGbl_GpeValid[GpeNumber];

    /*
     * Figure out the bit offset for this GPE within the target register.
     */
    BitMask = AcpiGbl_DecodeTo8bit [MOD_8 (GpeNumber)];

    /*
     * Read the current value of the register, clear the appropriate bit,
     * and write out the new register value to disable the GPE.
     */
    InByte = 0;
    AcpiOsReadPort (AcpiGbl_GpeRegisters[RegisterIndex].EnableAddr, &InByte, 8);
    AcpiOsWritePort (AcpiGbl_GpeRegisters[RegisterIndex].EnableAddr,
                (InByte & ~BitMask), 8);
}

static mng_bool
mng_close_stream_callback (mng_handle mng_h)
{
    FUNCTION_ENTRY();
    FUNCTION_EXIT();
  return MNG_TRUE;
}

void
AcpiHwClearGpe (
    UINT32                  GpeNumber)
{
    UINT32                  RegisterIndex;
    UINT32                  BitMask;


    FUNCTION_ENTRY ();


    /*
     * Translate GPE number to index into global registers array.
     */
    RegisterIndex = AcpiGbl_GpeValid[GpeNumber];

    /*
     * Figure out the bit offset for this GPE within the target register.
     */
    BitMask = AcpiGbl_DecodeTo8bit [MOD_8 (GpeNumber)];

    /*
     * Write a one to the appropriate bit in the status register to
     * clear this GPE.
     */
    AcpiOsWritePort (AcpiGbl_GpeRegisters[RegisterIndex].StatusAddr, BitMask, 8);
}

static mng_bool
mng_read_data_callback (mng_handle mng_h,
			mng_ptr buffer,
			mng_uint32 bytes_requested,
        		mng_uint32 * bytes_read)
{
    FUNCTION_ENTRY();
    *bytes_read = 0;
    return MNG_FALSE;
  guint available_mng_food;

  GtkMngView * mng_view = GTK_MNG_VIEW (mng_get_userdata (mng_h));

  available_mng_food = mng_view->bytes_to_eat - mng_view->bytes_eaten;
  if (available_mng_food > 0 && mng_view->mng_food != NULL)
    {
      * bytes_read = (mng_uint32) MIN ((mng_uint32) available_mng_food, bytes_requested);
      memcpy (buffer, mng_view->mng_food + mng_view->bytes_eaten, * bytes_read);
      mng_view->bytes_eaten += * bytes_read;
      FUNCTION_EXIT();
      return MNG_TRUE;
    }
  else {
      FUNCTION_EXIT();
    return MNG_FALSE;
  }
}

/*
* Class:     org_trafodion_jdbc_t2_T2Driver
* Method:    setCharsetEncodingOverride
* Signature: (I)Ljava/lang/String;
* Note: This function is a generic implementation to allow setting the
*       char set override encoding for the given charset (currently only the ISO88591
*       column is allowed to be overriden)
*/
JNIEXPORT void JNICALL Java_org_trafodion_jdbc_t2_T2Driver_setCharsetEncodingOverride(JNIEnv *jenv, jclass jcls,
																					jint charset, jstring encodingOverride)
{
	FUNCTION_ENTRY("Java_org_trafodion_jdbc_t2_T2Driver_setCharsetEncodingOverride",
		("charset=%ld, encodingOverride=%s",charset, DebugJString(jenv,encodingOverride)));

	//Added for connect/disconnect impro.
		 if (srvrGlobal == NULL)
		 MEMORY_ALLOC_PERM(srvrGlobal,SRVR_GLOBAL_Def)

	for (int idx=0; idx<gJNICache.totalCharsets; idx++)
		if (charset == gJNICache.charsetInfo[idx].charset)
		{
			const char *nEncodingOverride = JNI_GetStringUTFChars(jenv,encodingOverride, NULL);
			if (strcmp(nEncodingOverride,defaultEncodingOption) == 0)
			{
				gJNICache.charsetInfo[idx].useDefaultEncoding = TRUE;
			}
			else
			{
				gJNICache.charsetInfo[idx].useDefaultEncoding = FALSE;
			}
			JNI_ReleaseStringUTFChars(jenv,encodingOverride, nEncodingOverride);
		}
		FUNCTION_RETURN_VOID((NULL));
}

bool ParseBAND ( char *text, const sOptionTableInfo &info, sRejectOptionRMB *option )
{
    FUNCTION_ENTRY ( NULL, "ParseBAND", true );

    REJECT_OPTION_E type = OPTION_UNKNOWN;

    while ( isspace ( *text )) text++;

    if ( strncmp ( text, "BLIND", 5 ) == 0 ) {
        type = OPTION_BLIND;
        text += 5;
    } else if ( strncmp ( text, "SAFE", 5 ) == 0 ) {
        type = OPTION_SAFE;
        text += 4;
    } else {
        goto bad_option;
    }

    if ( isspace ( *text )) {
        bool retVal = ParseGeneric ( text, info, option );
        option->Banded = true;
        option->Info   = FindByType ( type );
        return retVal;
    }

bad_option:

    ParseError ( "Invalid BAND option." );
    return false;
}

/*
* Class:     org_trafodion_jdbc_t2_T2Driver
* Method:    checkLibraryVersion
* Signature: (Ljava/lang/String;)V
*/
JNIEXPORT void JNICALL Java_org_trafodion_jdbc_t2_T2Driver_checkLibraryVersion(JNIEnv *jenv, jclass jcls,
																			 jstring javaVproc)
{


#ifdef NSK_PLATFORM	// Linux port - ToDo txn related
		int cliret = client_initialization();//by venu for TSLX
		if (cliret != 1)//client init return 1 on success
		{

				DEBUG_OUT(DEBUG_LEVEL_TXN,("TSLX initialization failed %d", cliret));

		}
		DEBUG_OUT(DEBUG_LEVEL_TXN,("TSLX Initialization done"));
#endif

	//Added for R3.0 Transaction issue sol. 10-100430-9906


	FUNCTION_ENTRY("Java_org_trafodion_jdbc_t2_T2Driver_checkLibraryVersion",("javaVproc=%s",
		DebugJString(jenv,javaVproc)));

	// Set the TMLIB cleanup 
	setTM_enable_cleanup();

#ifdef NSK_PLATFORM		// Linux port
  	short status = tmfInit();

  	DEBUG_OUT(DEBUG_LEVEL_TXN,("tmfInit() returned %d", status));

  	if (status != 0)
  	{
  		throwTransactionException(jenv, status);
  		FUNCTION_RETURN_VOID(("status(%d) is non-zero",status));
	}
#endif

//End





	if (javaVproc && !driverVersionChecked)
	{
		const char *java_vproc_str = JNI_GetStringUTFChars(jenv,javaVproc, NULL);
		if (java_vproc_str)
		{
			if (strcmp(java_vproc_str,driverVproc)!=0)
			{
				printf("JDBC Library Version Error - Jar: %s Jni: %s\n",
					java_vproc_str,driverVproc);
				abort();
			}
			JNI_ReleaseStringUTFChars(jenv,javaVproc, java_vproc_str);
			driverVersionChecked = true;
		}
	}
	FUNCTION_RETURN_VOID((NULL));
}