/* -*-C++-*-
**********************************************************************
*
* File:         LmLangManagerC.cpp
* Description:  Language Manager for C
*
* Created:      05/15/2008
* Language:     C++
*
// @@@ START COPYRIGHT @@@
//
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.
//
// @@@ END COPYRIGHT @@@
**********************************************************************/

#include "LmCommon.h"
#include "LmLangManagerC.h"
#include "LmContManager.h"
#include "LmRoutineC.h"
#include "LmRoutineCSql.h"
#include "LmRoutineCSqlRow.h"
#include "LmRoutineCSqlRowTM.h"
#include "LmRoutineCppObj.h"
#include "LmExtFunc.h"
#include "LmDebug.h"
#include "sqludr.h"

LmLanguageManagerC::LmLanguageManagerC(
  LmResult &result,
  NABoolean commandLineMode,
  ComDiagsArea *diagsArea)
  : LmLanguageManager(commandLineMode),
    diagsArea_(diagsArea)
{
  setRoutineIsActive(FALSE);
  contManager_ = new (collHeap()) LmContainerManagerSimple(this);
  result = LM_OK;
}

LmLanguageManagerC::~LmLanguageManagerC()
{
  delete contManager_;
}

LmResult LmLanguageManagerC::validateRoutine(
  ComUInt32     numSqlParam,
  ComFSDataType paramType[],
  ComUInt32     paramSubType[],
  ComColumnDirection direction[],
  const char    *routineName,
  const char    *containerName,
  const char    *externalPath,
  char          *sigBuf,
  ComUInt32     sigLen,
  ComFSDataType resultType,
  ComUInt32     resultSubType,
  ComUInt32     numResultSets,
  const char    *metaContainerName,
  const char    *optionalSig,
  ComDiagsArea  *diagsArea)
{
  return LM_OK;
}

LmResult LmLanguageManagerC::getRoutine(
  ComUInt32    numSqlParam,
  LmParameter  parameters[],
  ComUInt32   numTableInfo,
  LmTableInfo tableInfo[],
  LmParameter  *returnValue,
  ComRoutineParamStyle paramStyle,
  ComRoutineTransactionAttributes transactionAttrs,
  ComRoutineSQLAccess sqlAccessMode,
  const char   *parentQid,
  ComUInt32    inputRowLen,
  ComUInt32    outputRowLen,
  const char   *sqlName,
  const char   *externalName,
  const char   *routineSig,
  const char   *containerName,
  const char   *externalPath,
  const char   *librarySqlName,
  const char   *currentUserName,
  const char   *sessionUserName,
  ComRoutineExternalSecurity externalSecurity,
  Int32        routineOwnerId,
  LmRoutine    **handle,
  LmHandle     getNextRowPtr,
  LmHandle     emitRowPtr,
  ComUInt32    maxResultSets,
  ComDiagsArea *diagsArea)
{
  *handle = NULL;
  LmContainer *container = NULL;
  LmResult result = LM_OK;
  const char *operation = "dlsym";

  ComDiagsArea *da = (diagsArea != NULL) ? diagsArea : diagsArea_;

  // Get the requested container from the CM.
  result = contManager_->getContainer(containerName, externalPath,
                                      &container, da);
  if (result == LM_ERR)
    return LM_ERR;
  
  // Get a handle to the requested routine
  LmHandle routinePtr = NULL;

  if (paramStyle != COM_STYLE_CPP_OBJ)
    {
      routinePtr = getRoutinePtr(container->getHandle(), externalName);

      if (routinePtr == NULL)
        {
          char *libraryName = new (collHeap())
            char[str_len(externalPath) + str_len(containerName) + 2];
          sprintf(libraryName, "%s/%s", externalPath, containerName);

          *da << DgSqlCode(-LME_DLL_METHOD_NOT_FOUND)
              << DgString0(externalName)
              << DgString1(libraryName);

          addDllErrors(*da, operation, FALSE);

          NADELETEBASIC(libraryName, collHeap());
          return LM_ERR;
        }
    }

  // allocate an LM handle for the external method.
  LmRoutine *routineHandle = NULL;
  if (paramStyle == COM_STYLE_SQL)
  {
    routineHandle =
      new (collHeap()) LmRoutineCSql(sqlName,
                                     externalName,
                                     librarySqlName,
                                     numSqlParam,
                                     (char *)routineSig,
                                     maxResultSets,
                                     transactionAttrs,
                                     sqlAccessMode,
                                     externalSecurity,
                                     routineOwnerId,
                                     parentQid,
                                     inputRowLen,
                                     outputRowLen,
                                     currentUserName,
                                     sessionUserName,
                                     parameters,
                                     this,
                                     routinePtr,
                                     container,
                                     da);
  }
  else if (paramStyle == COM_STYLE_SQLROW)
  {
    routineHandle =
      new (collHeap()) LmRoutineCSqlRow(sqlName,
                                        externalName,
                                        librarySqlName,
                                        numSqlParam,
                                        (char *)routineSig,
                                        maxResultSets,
                                        transactionAttrs,
                                        sqlAccessMode,
                                        externalSecurity,
                                        routineOwnerId,
                                        parentQid,
                                        inputRowLen,
                                        outputRowLen,
                                        currentUserName,
                                        sessionUserName,
                                        parameters,
                                        this,
                                        routinePtr,
                                        container,
                                        da);
  }
  else if (paramStyle == COM_STYLE_SQLROW_TM)
  {
    routineHandle =
      new (collHeap()) LmRoutineCSqlRowTM(sqlName,
                                        externalName,
                                        librarySqlName,
                                        numSqlParam,
                                        numTableInfo,
                                        tableInfo,
                                        (char *)routineSig,
                                        maxResultSets,
                                        transactionAttrs,
                                        sqlAccessMode,
                                        externalSecurity,
                                        routineOwnerId,
                                        parentQid,
                                        inputRowLen,
                                        outputRowLen,
                                        currentUserName,
                                        sessionUserName,
                                        parameters,
                                        this,
                                        routinePtr,
                                        getNextRowPtr,
                                        emitRowPtr,
                                        container,
                                        da);
  }
  else if (paramStyle == COM_STYLE_CPP_OBJ)
  {
    // need to call getObjRoutine for this parameter style
    LM_ASSERT(0);
  }
  else 
  {
    // XXX LM_ASSERT(0);
    char *paramStyleMsg = new (collHeap())
      char[100];
    sprintf(paramStyleMsg, "Unknown ParameterStyle(%d)", paramStyle);

    *da << DgSqlCode(-LME_VALIDATION_FAILED)
        << DgString0(externalName)
        << DgString1(paramStyleMsg);

    addDllErrors(*da, operation, FALSE);
  }

  // Verify the handle.
  if (routineHandle == NULL)
  {
    // DiagsArea is already filled
    if (container)
      contManager_->putContainer(container);
    return LM_ERR;
  }
  else
  {
    *handle = routineHandle;
    return LM_OK;
  }
}

LmResult LmLanguageManagerC::getObjRoutine(
     const char            *serializedInvocationInfo,
     int                    serializedInvocationInfoLen,
     const char            *serializedPlanInfo,
     int                    serializedPlanInfoLen,
     ComRoutineLanguage     language,
     ComRoutineParamStyle   paramStyle,
     const char            *externalName,
     const char            *containerName,
     const char            *externalPath,
     const char            *librarySqlName,
     LmRoutine            **handle,
     ComDiagsArea          *da)
{
  LmResult result;
  tmudr::UDRInvocationInfo *invocationInfo = NULL;
  tmudr::UDRPlanInfo *planInfo = NULL;
  LmContainer *container = NULL;

  *handle = NULL;

  // Get the requested container from the CM.
  result = contManager_->getContainer(containerName,
                                      externalPath,
                                      &container,
                                      da);
  if (result == LM_ERR)
    return LM_ERR;
  
  // search the DLL for the method that creates the tmudr::UDRInterface object
  LmHandle factoryMethodPtr = getRoutinePtr(container->getHandle(), externalName);
  tmudr::UDR *interfacePtr = NULL;

  if (factoryMethodPtr == NULL)
    {
      *da << DgSqlCode(-LME_DLL_METHOD_NOT_FOUND)
          << DgString0(externalName)
          << DgString1(containerName);

      addDllErrors(*da, "dlsym", FALSE);

      return LM_ERR;
    }

  try
    {
      if (serializedInvocationInfoLen > 0)
        {
          // unpack invocation and plan infos
          invocationInfo = new tmudr::UDRInvocationInfo;
          invocationInfo->deserializeObj(serializedInvocationInfo,
                                         serializedInvocationInfoLen);
        }

      if (serializedPlanInfoLen > 0)
        {
          planInfo = new tmudr::UDRPlanInfo(invocationInfo, 0);
          planInfo->deserializeObj(serializedPlanInfo,
                                   serializedPlanInfoLen);
        }

      tmudr::CreateInterfaceObjectFunc fPtr =
        reinterpret_cast<tmudr::CreateInterfaceObjectFunc>(factoryMethodPtr);

      // call the factory method
      interfacePtr = (*fPtr)();

      if (interfacePtr == NULL)
        {
          *da << DgSqlCode(-LME_FACTORY_METHOD)
              << DgString0(externalName)
              << DgString1(containerName)
              << DgString2("Factory method returned NULL");
          result = LM_ERR;
        }
    }
  catch (tmudr::UDRException e)
    {
      *da << DgSqlCode(-LME_FACTORY_METHOD)
          << DgString0(externalName)
          << DgString1(containerName)
          << DgString2(e.getMessage().data());
      result = LM_ERR;
    }
  catch (...)
    {
      *da << DgSqlCode(-LME_FACTORY_METHOD)
          << DgString0(externalName)
          << DgString1(containerName)
          << DgString2("General exception");
      result = LM_ERR;
    }

  if (result == LM_OK && invocationInfo != NULL)
    {
      // create the language manager routine, which will take
      // ownership of the interface object
      ComRoutineTransactionAttributes transactionAttrs = COM_NO_TRANSACTION_REQUIRED;
      ComRoutineSQLAccess sqlAccessMode = COM_NO_SQL;
      ComRoutineExternalSecurity externalSecurity = COM_ROUTINE_EXTERNAL_SECURITY_DEFINER;

      // for now we don't allow a choice, once we do we need to translate enums
      LM_ASSERT(invocationInfo->sqlTransactionType_ ==
                tmudr::UDRInvocationInfo::REQUIRES_NO_TRANSACTION);
      LM_ASSERT(invocationInfo->sqlAccessType_ ==
                tmudr::UDRInvocationInfo::CONTAINS_NO_SQL);
      LM_ASSERT(invocationInfo->sqlRights_ ==
                tmudr::UDRInvocationInfo::INVOKERS_RIGHTS);

      *handle =
        new (collHeap()) LmRoutineCppObj(invocationInfo,
                                         planInfo,
                                         interfacePtr,
                                         invocationInfo->getUDRName().c_str(),
                                         externalName,
                                         librarySqlName,
                                         0,
                                         transactionAttrs,
                                         sqlAccessMode,
                                         externalSecurity,
                                         0, // routine owner id is 0 for now
                                         this,
                                         container,
                                         da);
    }
  else
    {
      // In the error or validation case, get rid of the allocated info.
      // invocationInfoLen will be 0 in the validation case, where
      // we return LM_OK and NULL for the routine when validation is
      // successful.
      if (interfacePtr)
        delete interfacePtr;
      if (invocationInfo)
        delete invocationInfo;
      if (planInfo)
        delete planInfo;
      if (container)
        contManager_->putContainer(container);
    }

  return result;
}

LmResult LmLanguageManagerC::putRoutine(
  LmRoutine    *routine,
  ComDiagsArea *diagsArea)
{
  if (routine == NULL)
    return LM_OK;

  // make a final call or the equivalent, if needed
  LmResult result = routine->handleFinalCall();

  // De-ref the container.
  if (routine->container())
    contManager_->putContainer(routine->container());

  // De-allocate the handle.
  delete routine;

  return result;
}

LmResult LmLanguageManagerC::invokeRoutine(
  LmRoutine    *handle,
  void         *inputRow,
  void         *outputRow,
  ComDiagsArea *diagsArea)
{
  LmRoutine *routine = (LmRoutine *) handle;
  LM_ASSERT(routine);
  LmResult result = LM_OK;

  if (routine->getParamStyle() == COM_STYLE_CPP_OBJ)
    {
      LmRoutineCppObj *cppRoutine = static_cast<LmRoutineCppObj *>(routine);
      tmudr::UDRInvocationInfo *invocationInfo = cppRoutine->getInvocationInfo();
      Int32 dummy1, dummy2;

      // this path is only used for the run-time call, where we
      // have already received the UDRInvocationInfo/UDRPlanInfo
      result = cppRoutine->invokeRoutineMethod(
           tmudr::UDRInvocationInfo::RUNTIME_WORK_CALL,
           NULL,    // invocation info already there
           0,
           &dummy1, // expecting no updated invocation info
           NULL,    // plan info is already there or not used
           0,
           0,
           &dummy2, // expecting no updated plan info
           (char *) inputRow,
           invocationInfo->par().getRecordLength(),
           (char *) outputRow,
           invocationInfo->out().getRecordLength(),
           diagsArea);
    }
  else
    result = routine->invokeRoutine(inputRow, outputRow, diagsArea);

  return result;
}

LmHandle LmLanguageManagerC::createLoader(
  const char   *externalPath,
  ComDiagsArea *da)
{
  return new (collHeap()) LmCLoader();
}

void LmLanguageManagerC::deleteLoader(LmHandle loader)
{
  // This function deletes LmCLoader object
  LmCLoader *cLoader = (LmCLoader *) loader;
  delete cLoader;
}

LmHandle LmLanguageManagerC::loadContainer(
  const char   *containerName,
  const char   *externalPath,
  LmHandle     extLoader,
  ComUInt32    *containerSize,
  ComDiagsArea *da)
{
  return loadDll(containerName, externalPath, extLoader, 
                          containerSize, da, collHeap());
}

void LmLanguageManagerC::unloadContainer(LmHandle containerHandle)
{
  unloadDll(containerHandle, diagsArea_);
}

LmResult LmLanguageManagerC::getSystemProperty(
  const char   *key,
  char         *value,
  ComUInt32    bufferLen,
  ComBoolean   &propertyIsSet,
  ComDiagsArea *diagsArea)
{
  // TBD: Need to update this with getenv() function call
  propertyIsSet = FALSE;
  return LM_OK;
}

LmResult LmLanguageManagerC::setSystemProperty(
  const char   *key,
  const char   *value,
  ComDiagsArea *diagsArea)
{
  // TBD: Need to update this with setenv() function call
  return LM_OK;
}

LmCLoader::LmCLoader()
{
}

LmCLoader::~LmCLoader()
{
}