/**********************************************************************
// @@@ 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 @@@
**********************************************************************/
/* -*-c++-*-
*****************************************************************************
*
* file:         udrload.cpp
* description:  this is the module that processes udr load messages.
*               the tasks for this process are to :
*               . extract sp descriptive attributes from message
*               . extract sp parameter attributes from message
*               . build SPInfo data structure and populate with attributes
*               . return sp id (creation timestamp) to client
*               . handle errors returned from lm.
*               . deal with resource allocation problems of SPInfo data structures
*
* created:      01/01/2001
* language:     c++
*
*
*****************************************************************************
*/

#include "udrextrn.h"
#include "spinfo.h"
#include "udrdefs.h"
#include "udrutil.h"
#include "ComDiags.h"
#include "ComSmallDefs.h"
#include "UdrStreams.h"
#include "UdrExeIpc.h"
#include "LmRoutineC.h"
#include "LmRoutineCppObj.h"
#include "LmRoutineJavaObj.h"
#include "LmJavaOptions.h"
#include "udrdecs.h"
#include "spinfoCallback.h"
// include the file generated by this command and checked into git:
// javah -d $TRAF_HOME/../sql/langman org.trafodion.sql.udr.UDR 
#include "org_trafodion_sql_udr_UDR.h"

class UdrServerReplyStream;

SPInfo * processLoadParameters(UdrGlobals *UdrGlob,
                               UdrLoadMsg &request,
                               ComDiagsArea &d);
void displayLoadParameters(UdrLoadMsg &request);
void reportLoadResults(UdrGlobals *UdrGlob, SPInfo *sp, LmRoutine *lmr_);
void copyRoutineOptionalData(UdrLoadMsg &request, SPInfo *sp);

void processALoadMessage(UdrGlobals *UdrGlob,
                         UdrServerReplyStream &msgStream,
                         UdrLoadMsg &request,
                         IpcEnvironment &env)
{
  const char *moduleName = "processALoadMessage";
  char errorText[MAXERRTEXT];

  ComDiagsArea *diags = ComDiagsArea::allocate(UdrGlob->getIpcHeap());

  doMessageBox(UdrGlob, TRACE_SHOW_DIALOGS,
               UdrGlob->showLoad_, moduleName);

  NABoolean showLoadLogic = (UdrGlob->verbose_ &&
                             UdrGlob->traceLevel_ >= TRACE_IPMS &&
                             UdrGlob->showLoad_);

  if (showLoadLogic)
  {
    ServerDebug("[UdrServ (%s)] Processing load request", moduleName);
  }

  // UDR_LOAD message always comes with transaction and they are out
  // side Enter Tx and Exit Tx pair. Make sure we are under correct
  // transaction.
  msgStream.activateCurrentMsgTransaction();

  //
  // Check to see if the incoming UDR handle has already been seen
  //
  NABoolean handleAlreadyExists = FALSE;
  SPInfo *sp = UdrGlob->getSPList()->spFind(request.getHandle());
  if (sp)
  {
    handleAlreadyExists = TRUE;
    if (showLoadLogic)
    {
      ServerDebug("    Duplicate handle arrived");
      ServerDebug("    SPInfoState is %s", sp->getSPInfoStateString());
    }

    if (sp->getSPInfoState() != SPInfo::UNLOADING)
    {
      //
      // An SPInfo exists but it is not one of the token instances to
      // represent an out-of-sequence LOAD/UNLOAD. This is an internal
      // error. Something has been botched in the message protocol.
      //
      char buf[100];
      convertInt64ToAscii(request.getHandle(), buf);
      *diags << DgSqlCode(-UDR_ERR_DUPLICATE_LOADS);
      *diags << DgString0(buf);
    }
    else
    {
      // The LOAD/UNLOAD requests for this handle arrived
      // out-of-sequence. Nothing to do at this point. An empty reply
      // will be generated later in this function.
    }
  }

  if (!handleAlreadyExists)
  {
    if (!UdrHandleIsValid(request.getHandle()))
    {
      *diags << DgSqlCode(-UDR_ERR_MISSING_UDRHANDLE);
      *diags << DgString0("Load Message");
    }
    else
    {
      //
      // First process the metadata in the LOAD requests and then
      // contact Language Manager to load the SP.
      //
      sp = processLoadParameters(UdrGlob, request, *diags);
      
      if (showLoadLogic)
      {
        ServerDebug("[UdrServ (%s)]  About to call LM::getRoutine",
                    moduleName);
      }
      
      if (sp == NULL)
      {
        *diags << DgSqlCode(-UDR_ERR_UNABLE_TO_ALLOCATE_MEMORY);
        *diags << DgString0("SPInfo");
      }
      else
      {
        UdrGlob->setCurrSP(sp);
        LmRoutine *lmRoutine;
        LmResult lmResult;
        LmLanguageManager *lm =
          UdrGlob->getOrCreateLM(lmResult, sp->getLanguage(), diags);
        LmHandle emitRowFuncPtr;

        if (sp->getParamStyle() == COM_STYLE_CPP_OBJ)
          emitRowFuncPtr = (LmHandle)&SpInfoEmitRowCpp;
        else
          emitRowFuncPtr = (LmHandle)&SpInfoEmitRow;
        
        if (lm)
        {
          if (sp->getParamStyle() == COM_STYLE_JAVA_OBJ ||
              sp->getParamStyle() == COM_STYLE_CPP_OBJ)
            {
              lmResult = lm->getObjRoutine(
                   request.getUDRSerInvocationInfo(),
                   request.getUDRSerInvocationInfoLen(),
                   request.getUDRSerPlanInfo(),
                   request.getUDRSerPlanInfoLen(),
                   sp->getLanguage(),
                   sp->getParamStyle(),
                   sp->getExternalName(),
                   sp->getContainerName(),
                   sp->getExternalPathName(),
                   sp->getLibrarySqlName(),
                   &lmRoutine,
                   diags);

              if (lmRoutine && lmResult == LM_OK)
                {
                  if (sp->getParamStyle() == COM_STYLE_CPP_OBJ)
                    {
                      LmRoutineCppObj *cppRoutine =
                        static_cast<LmRoutineCppObj *>(lmRoutine);

#ifndef NDEBUG
                      int debugLoop = 2;

                      if (cppRoutine->getInvocationInfo()->getDebugFlags() &
                          tmudr::UDRInvocationInfo::DEBUG_LOAD_MSG_LOOP)
                        debugLoop = 1;
                      // go into a loop to allow the user to attach a debugger,
                      // if requested, set debugLoop = 2 in the debugger to get out
                      while (debugLoop < 2)
                        debugLoop = 1-debugLoop;
#endif

                    }
                  else if (sp->getParamStyle() == COM_STYLE_JAVA_OBJ)
                    {
                      LmRoutineJavaObj *javaObjRoutine =
                        static_cast<LmRoutineJavaObj *>(lmRoutine);

                      // avoid unpacking the UDRInvocationInfo to look
                      // up row lengths and take those from the request
                      // message instead
                      javaObjRoutine->setRowLengths(
                           request.getInputRowSize(),
                           request.getOutputRowSize());

                      // provide pointers of the JNI functions with special
                      // parameter lists
                      javaObjRoutine->setJNIFunctionPtrs(
                           reinterpret_cast<void *>(&Java_org_trafodion_sql_udr_UDR_SpInfoGetNextRowJava),
                           reinterpret_cast<void *>(&Java_org_trafodion_sql_udr_UDR_SpInfoEmitRowJava));
                    }

                  // set function pointers for functions provided
                  // by tdm_udrserv
                  lmResult = lmRoutine->setFunctionPtrs(SpInfoGetNextRow,
                                                        SpInfoEmitRowCpp,
                                                        diags);

                  if (lmResult == LM_OK)
                    // add items to the UDRInvocationInfo that are not
                    // known at compile time (total # of instances is
                    // kind of known, but we want to give the executor a
                    // chance to change it)
                    lmResult = lmRoutine->setRuntimeInfo(
                         request.getParentQid(),
                         request.getNumInstances(),
                         request.getInstanceNum(),
                         diags);
                }
            }
          else
            lmResult = lm->getRoutine(sp->getNumParameters(),
                                      sp->getLmParameters(),
                                      sp->getNumTables(),
                                      sp->getLmTables(),
                                      sp->getReturnValue(),
                                      sp->getParamStyle(),
                                      sp->getTransactionAttrs(),
                                      sp->getSQLAccessMode(),
                                      sp->getParentQid(),
                                      sp->getRequestRowSize(),
                                      sp->getReplyRowSize(),
                                      sp->getSqlName(),
                                      sp->getExternalName(),
                                      sp->getRoutineSig(),
                                      sp->getContainerName(),
                                      sp->getExternalPathName(),
                                      sp->getLibrarySqlName(),
                                      UdrGlob->getCurrentUserName(),
                                      UdrGlob->getSessionUserName(),
                                      sp->getExternalSecurity(),
                                      sp->getRoutineOwnerId(),
                                      &lmRoutine,
                                      (LmHandle)&SpInfoGetNextRow,
                                      emitRowFuncPtr,
                                      sp->getMaxNumResultSets(),
                                      diags);
        }
        
        if (lmResult == LM_OK)
        {
          if (lmRoutine == NULL)
          {
            *diags << DgSqlCode(-UDR_ERR_MISSING_LMROUTINE);
            *diags << DgString0("error: returned a null LM handle");
            *diags << DgInt1((Int32)0);
          }
          else
          {
            sp->setLMHandle(lmRoutine);

	    // Retrieve any optional data from UdrLoadMsg.
	    copyRoutineOptionalData(request, sp);

            reportLoadResults(UdrGlob, sp, lmRoutine);
            sp->setSPInfoState(SPInfo::LOADED);
          }

        } // lmResult == LM_OK

        if (showLoadLogic)
        {
          if (lmResult == LM_OK)
          {
            sprintf(errorText,
                    "[UdrServ (%.30s)]  LM::getRoutine was successful.",
                    moduleName);
          }
          else
          {
            sprintf(errorText,
                    "[UdrServ (%.30s)]  LM::getRoutine resulted in error.",
                    moduleName);
          }
          ServerDebug(errorText);
          doMessageBox(UdrGlob, TRACE_SHOW_DIALOGS,
                       UdrGlob->showMain_, errorText);
        }

        if (sp && !(sp->isLoaded()))
        {
          sp->setSPInfoState(SPInfo::LOAD_FAILED);
        }

      } // if (sp == NULL) else ...
    } // if (handle is not valid) else ...
  } // !handleAlreadyExists

  // build a reply and send it
  msgStream.clearAllObjects();

  UdrLoadReply *reply = new (UdrGlob->getIpcHeap())
    UdrLoadReply(UdrGlob->getIpcHeap());

  if (reply == NULL)
  {  // no reply buffer build...
    controlErrorReply(UdrGlob, msgStream, UDR_ERR_MESSAGE_PROCESSING,
                      INVOKE_ERR_NO_REPLY_BUFFER, NULL);
    return;
  }

  // Only return a valid UDR Handle if diagnostics are not present and
  // no LM errors occurred. We also return a valid handle if this LOAD
  // arrived out-of-sequence after the UNLOAD and no diagnostics have
  // been generated yet.
  if (diags && diags->getNumber() > 0)
  {
    reply->setHandle(INVALID_UDR_HANDLE);
  }
  else if (sp)
  {
    if (sp->isLoaded() || handleAlreadyExists)
    {
      reply->setHandle(sp->getUdrHandle());
    }
    else
    {
      reply->setHandle(INVALID_UDR_HANDLE);
    }
  }

  msgStream << *reply;

  if (diags && diags->getNumber() > 0)
  {
    msgStream << *diags;
    UdrGlob->numErrUDR_++;
    UdrGlob->numErrSP_++;
    UdrGlob->numErrLoadSP_++;
    if (showLoadLogic)
      dumpDiagnostics(diags, 2);
  }

  if (showLoadLogic)
  {
    ServerDebug("[UdrServ (%s)] About to send LOAD reply", moduleName);
  }

#ifdef _DEBUG
  if (UdrGlob && UdrGlob->getJavaLM())
  {
    sleepIfPropertySet(*(UdrGlob->getJavaLM()),
                       "MXUDR_LOAD_DELAY", diags);
  }
#endif // _DEBUG

  sendControlReply(UdrGlob, msgStream, sp);

  if (diags)
  {
    diags->decrRefCount();
  }

  reply->decrRefCount();

} // processALoadMessage

SPInfo *processLoadParameters(UdrGlobals *UdrGlob,
                              UdrLoadMsg &request,
                              ComDiagsArea &d)
{
  const char *moduleName = "processLoadParameters";
  Lng32 oldDiags = 0;
  Lng32 newDiags = 0;
  
  doMessageBox(UdrGlob, TRACE_SHOW_DIALOGS,
               UdrGlob->showLoad_, moduleName);
  // check for test mode processing...
  
  SPInfo *sp = NULL;
  int numRetries = 0;
  
  // process message parameters...
  
  if (UdrGlob->traceLevel_ >= TRACE_DETAILS &&
      UdrGlob->showLoad_)
  {
    displayLoadParameters(request);
  }
  
  doMessageBox(UdrGlob, TRACE_SHOW_DIALOGS,
               UdrGlob->showLoad_, "create SPInfo");
  
  oldDiags = d.getNumber();

  while (sp == NULL && numRetries < 1)
    {
      sp = new (UdrGlob->getUdrHeap()) SPInfo(UdrGlob, UdrGlob->getUdrHeap(),
                                          request.getHandle(),
                                          (char *)request.getSqlName(),
                                          (char *)request.getRoutineName(),
                                          (char *)request.getSignature(),
                                          (char *)request.getContainerName(),
                                          (char *)request.getExternalPath(),
                                          (char *)request.getLibrarySqlName(),
                                          request.getNumParameters(),
                                          request.getNumInValues(),
                                          request.getNumOutValues(),
                                          request.getMaxResultSets(),
                                          request.getTransactionAttrs(),
                                          request.getSqlAccessMode(),
                                          request.getLanguage(),
                                          request.getParamStyle(),
                                          request.isIsolate(),
                                          request.isCallOnNull(),
                                          request.isExtraCall(),
                                          request.isDeterministic(),
                                          request.getExternalSecurity(),
                                          request.getRoutineOwnerId(),
                                          request.getInBufferSize(),
                                          request.getOutBufferSize(),
                                          request.getInputRowSize(),
                                          request.getOutputRowSize(),
                                          /* ComDiagsArea */ d,
                                          (char *)request.getParentQid());
      if (sp == NULL)
        {  // memory problem
          UdrGlob->getSPList()->releaseOldestSPJ(/* ComDiagsArea */ d);
          numRetries++;
        }
    }

  if (sp == NULL)
    {
      return NULL;
    }
  
  newDiags = d.getNumber();
  
  if (oldDiags != newDiags)
  {
    // diagnostics generated in ctor for SPInfo
    // something bad has happened. Bail out.
    delete sp;
    return NULL;
  }
  
  // Process IN/INOUT parameters
  ComUInt32 i;
  for (i = 0; i < sp->getNumInParameters(); i++)
  {
    UdrParameterInfo &pi = (UdrParameterInfo &)request.getInParam(i);

    // Copy information from the UdrParameterInfo into the spinfo. The
    // spinfo will initialize an LmParameter instance for this
    // parameter.
    sp->setInParam(i, pi);
  }
  
  // Process OUT/INOUT parameters
  for (ComUInt32 j = 0; j < sp->getNumOutParameters(); j++)
  {
    UdrParameterInfo &po = (UdrParameterInfo &)request.getOutParam(j);

    // Copy information from the UdrParameterInfo into the spinfo. The
    // spinfo will initialize an LmParameter instance for this
    // parameter. Note for INOUT parameters, the LmParameter will not
    // be completely re-initialized. It was partially initialized in
    // the loop above for input parameters. This setOutParam call
    // completes the LmParameter initialization.
    sp->setOutParam(j, po);
  }

  // Process table input info if any
  if(sp->getParamStyle() == COM_STYLE_SQLROW_TM ||
     sp->getParamStyle() == COM_STYLE_CPP_OBJ ||
     sp->getParamStyle() == COM_STYLE_JAVA_OBJ)
  {
    sp->setNumTableInfo(request.getNumInputTables());
    sp->setTableInputInfo(request.getInputTables()); 
  }

  if (request.getUdrJavaDebugPort() > 0 &&
      sp->getLanguage() == COM_LANGUAGE_JAVA &&
      UdrGlob->getJavaLM() == NULL) // Langman not started already
  {
    // Add debug options to the UDR globals. Note that this will
    // only work for the first UDR in this tmd_udrserv process,
    // since the options are evaluated when the JVM gets started.
    // Also note that the compiler will only generate these flags
    // for debug builds or for the DB_ROOT user (e.g. sqlci).
    char buf[200];

    int debugPort = request.getUdrJavaDebugPort();
    int timeout = request.getUdrJavaDebugTimeout();

    // if the debug port is a multiple of 1000 then add pid mod 1000
    // to the debug port, to be able to debug parallel queries with
    // multiple UDR servers
    if (debugPort % 1000 == 0)
      debugPort += (int) getpid() % 1000;

    if (timeout > 0)
      {
        // suspend the JVM and wait for <timeout> milliseconds for the
        // debugger to attach
        snprintf(
             buf,
             sizeof(buf),
             "-agentlib:jdwp=transport=dt_socket,address=%d,server=y,timeout=%d",
             debugPort,
             timeout);
        printf("Debugging tdm_udrserv JVM instance %d of %d, attach debugger to port %d within %d seconds\n",
               request.getInstanceNum(),
               request.getNumInstances(),
               debugPort,
               timeout/1000);
      }
    else
      {
        // don't suspend the JVM, attaching the debugger is optional
        snprintf(
             buf,
             sizeof(buf),
             "-agentlib:jdwp=transport=dt_socket,address=%d,server=y,suspend=n",
             debugPort);
        printf("Debugging tdm_udrserv JVM instance %d of %d, attach debugger to port %d\n",
               request.getInstanceNum(),
               request.getNumInstances(),
               debugPort);
      }

    UdrGlob->getJavaOptions()->addOption(buf, false);
  }

  if (UdrGlob->verbose_ &&
      UdrGlob->traceLevel_ >= TRACE_DETAILS &&
      UdrGlob->showLoad_)
  {
    sp->displaySPInfo(2);
  }
  
  if (UdrGlob->verbose_ &&
      UdrGlob->traceLevel_ >= TRACE_DATA_AREAS &&
      UdrGlob->showLoad_)
  {
    ServerDebug("  LmParameter array:");
    for (ComUInt32 i = 0; i < sp->getNumParameters(); i++)
    {
      dumpLmParameter(sp->getLmParameter(i), i, "    ");
    }
  }

  if (UdrGlob->verbose_ &&
      UdrGlob->traceLevel_ >= TRACE_DATA_AREAS &&
      UdrGlob->showLoad_)
    ServerDebug("");
  
  return sp;
} // processLoadParameters

void displayLoadParameters(UdrLoadMsg &request)
{
  ServerDebug("");
  ServerDebug("UDR load parameters:");
  ServerDebug("  UDR handle          : " INT64_SPEC , request.getHandle());
  ServerDebug("  sql name            : %s", request.getSqlName());
  ServerDebug("  routine name        : %s", request.getRoutineName());
  ServerDebug("  routine signature   : %s", request.getSignature());
  ServerDebug("  container name      : %s", request.getContainerName());
  ServerDebug("  external path name  : %s", request.getExternalPath());
  ServerDebug("  library SQL name    : %s", request.getLibrarySqlName());
  ServerDebug("  parent QID          : %s", request.getParentQid());
  
  const char *transString;
  switch (request.getTransactionAttrs() )
  {
    case COM_NO_TRANSACTION_REQUIRED:
      transString = "NO TRANSACTION REQUIRED";
      break;
    case COM_TRANSACTION_REQUIRED:
      transString = "TRANSACTION REQUIRED";
      break;    
    default:
      transString = "*** UNKNOWN ***";
      break;
  }
  ServerDebug("  transaction required     : %s", transString);

  const char *modeString;
  switch (request.getSqlAccessMode() )
  {
    case COM_NO_SQL:
      modeString = "NO SQL";
      break;
    case COM_CONTAINS_SQL:
      modeString = "CONTAINS SQL";
      break;
    case COM_READS_SQL:
      modeString = "READS SQL DATA";
      break;
    case COM_MODIFIES_SQL:
      modeString = "MODIFIES SQL DATA";
      break;
    default:
      modeString = "*** UNKNOWN ***";
      break;
  }
  ServerDebug("  sql access mode     : %s", modeString);

  const char *language;
  switch (request.getLanguage())
  {
    case COM_LANGUAGE_JAVA:
      language = "Java";
      break;

    case COM_LANGUAGE_C:
      language = "C";
      break;

    case COM_LANGUAGE_CPP:
      language = "C++";
      break;

    case COM_LANGUAGE_SQL:
      language = "SQL";
      break;

    default:
      language = "*** UNKNOWN ***";
      break;
  }
  ServerDebug("  language            : %s", language);

  const char *externalSecurity;
  switch (request.getExternalSecurity())
  {
    case COM_ROUTINE_EXTERNAL_SECURITY_INVOKER:
      externalSecurity = "EXTERNAL SECURITY INVOKER";
      break;

    case COM_ROUTINE_EXTERNAL_SECURITY_DEFINER:
      externalSecurity = "EXTERNAL SECURITY DEFINER";
      break;

    default:
      externalSecurity = "*** UNKNOWN ***";
      break;
  }
  ServerDebug("  externalSecurity    : %s", externalSecurity);
  ServerDebug("  routine Owner Id    : %d",
              (Int32) request.getRoutineOwnerId());

  ServerDebug("  max result sets     : %d",
              (Int32) request.getMaxResultSets());
  ServerDebug("  num params          : %d",
              (Int32) request.getNumParameters());
  ServerDebug("  num in values       : %d",
              (Int32) request.getNumInValues());
  ServerDebug("  num out values      : %d",
              (Int32) request.getNumOutValues());
  ServerDebug("  udr flags           : %d",
              (Int32) request.getUdrFlags());

  if (request.isIsolate())
    ServerDebug("    isolate           : TRUE");
  else
    ServerDebug("    isolate           : FALSE");

  if (request.isCallOnNull())
    ServerDebug("    call on NULL      : TRUE");
  else
    ServerDebug("    call on NULL      : FALSE");

  if (request.isExtraCall())
    ServerDebug("    extra call        : TRUE");
  else
    ServerDebug("    extra call        : FALSE");

  if (request.isDeterministic())
    ServerDebug("    deterministic     : TRUE");
  else
    ServerDebug("    deterministic     : FALSE");

  ServerDebug("");
  
} // displayLoadParameters

void reportLoadResults(UdrGlobals *UdrGlob, SPInfo *sp, LmRoutine *lmr_)
{
  const char *moduleName = "reportLoadResults";
  
  doMessageBox(UdrGlob, TRACE_SHOW_DIALOGS,
               UdrGlob->showLoad_, moduleName);
  
  if (UdrGlob->verbose_ &&
      UdrGlob->traceLevel_ >= TRACE_DETAILS &&
      UdrGlob->showLoad_ )
  {
    ServerDebug("");
    ServerDebug("[UdrServ (%s)] LOAD message results:", moduleName);
    ServerDebug("  LOAD Udr Handle     : " INT64_SPEC ,
                (Int64) sp->getUdrHandle());
    ServerDebug("  LM result parameter : %d", (Int32) sp->getNumParameters());
    if (sp->getReturnValue() != NULL)
    {
      dumpLmParameter(*sp->getReturnValue(), 0, "    ");
    }
    if (lmr_)
    {
      ServerDebug("  LM routine          : ");
      dumpBuffer((unsigned char *)lmr_, sizeof(LmRoutine));
    }
    ServerDebug("");
  }

} // reportLoadResults

// Utility function to push optional data buffers from UdrLoadMsg
// into LM.
void copyRoutineOptionalData(UdrLoadMsg &request, SPInfo *sp)
{
  if (sp->getLanguage() != COM_LANGUAGE_C)
    return;
  
  ComUInt32 numBufs = request.getNumOptionalDataBufs();
  LmRoutineC *routine = (LmRoutineC *) sp->getLMHandle();
  routine->setNumPassThroughInputs(numBufs);
  
  for (ComUInt32 i = 0; i < numBufs; i++)
  {
    // Process each optional data buffer. Each buffer is a 4-byte
    // length field followed by data.
    ComUInt32 buflen = 0;
    char *dataBuf = request.getOptionalDataBuf(i);
    memcpy(&buflen, dataBuf, 4);
    if (buflen > 0)
      routine->setPassThroughInput(i, dataBuf + 4, buflen);
    else
      routine->setPassThroughInput(i, (void *)"", 0);
  }
}