method_scan.c

Go to the documentation of this file.

/*
 * Copyright 2008 Search Solution Corporation
 * Copyright 2016 CUBRID Corporation
 *
 *  Licensed 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.
 *
 */

/*
 * method_scan.c - Routines to implement scanning an array of values
 *                 received by the comm interface
 */

#ident "$Id$"

#include "config.h"

#include <string.h>

#include "method_scan.h"

#include "network_interface_sr.h"   /* TODO: should not be here */
#ifndef SERVER_MODE
#include "object_accessor.h"
#include "dbi.h"
#include "authenticate.h"
#endif
#include "xasl.h"

#if defined (SA_MODE)
#include "jsp_cl.h"
#endif /* defined (SA_MODE) */

#include "dbtype.h"
#include "object_primitive.h"
#include "object_representation.h"
#include "query_list.h"
#include "regu_var.hpp"

#if !defined(SERVER_MODE)
extern unsigned int db_on_server;
#endif

int method_Num_method_jsp_calls = 0;

#define ENTER_SERVER_IN_METHOD_CALL(save_pri_heap_id_) \
  do { \
    db_on_server = 1; \
    private_heap_id = save_pri_heap_id_; \
  } while (0)

#define EXIT_SERVER_IN_METHOD_CALL(save_pri_heap_id_) \
  do { \
     save_pri_heap_id_ = private_heap_id; \
     private_heap_id = 0; \
     db_on_server = 0; \
  } while (0)

static int method_open_value_array_scan (METHOD_SCAN_BUFFER * scan_buf);
static int method_close_value_array_scan (METHOD_SCAN_BUFFER * scan_buf);
static SCAN_CODE method_scan_next_value_array (METHOD_SCAN_BUFFER * scan_buf, VAL_LIST * val_list);
static int method_invoke (THREAD_ENTRY * thread_p, METHOD_SCAN_BUFFER * scan_buf);
static SCAN_CODE method_receive_results (THREAD_ENTRY * thread_p, METHOD_SCAN_BUFFER * scan_buf);

#ifndef SERVER_MODE
static void method_clear_scan_buffer (METHOD_SCAN_BUFFER * scan_buf);
#else
static VACOMM_BUFFER *method_initialize_vacomm_buffer (void);
static void method_free_vacomm_buffer (VACOMM_BUFFER * vacomm_buffer);
static SCAN_CODE method_receive_value (THREAD_ENTRY * thread_p, DB_VALUE * dbval, VACOMM_BUFFER * vacomm_buffer);
#endif /* SERVER_MODE */

/*
 * xs_open_va_scan () -
 *   return: int
 *   scan_buf(in)       : Value array buffer
 *   scanbuf_type(in)   : Method signature list
 */
static int
method_open_value_array_scan (METHOD_SCAN_BUFFER * scan_buffer_p)
{
  int num_methods;

  num_methods = scan_buffer_p->s.method_ctl.method_sig_list->num_methods;
  if (num_methods <= 0)
    {
      num_methods = MAX_XS_SCANBUF_DBVALS;  /* for safe-guard */
    }

  scan_buffer_p->dbval_list = (QPROC_DB_VALUE_LIST) malloc (sizeof (scan_buffer_p->dbval_list[0]) * num_methods);

  if (scan_buffer_p->dbval_list == NULL)
    {
      return ER_FAILED;
    }

#ifdef SERVER_MODE
  scan_buffer_p->vacomm_buffer = method_initialize_vacomm_buffer ();
  if (scan_buffer_p->vacomm_buffer == NULL)
    {
      return ER_FAILED;
    }
#endif /* SERVER_MODE */

  return NO_ERROR;
}

/*
 * method_close_value_array_scan () -
 *   return: int
 *   scan_buf(in)       : Value array buffer
 */
static int
method_close_value_array_scan (METHOD_SCAN_BUFFER * scan_buffer_p)
{
#ifdef SERVER_MODE
  method_free_vacomm_buffer (scan_buffer_p->vacomm_buffer);
  scan_buffer_p->vacomm_buffer = NULL;
#endif /* SERVER_MODE */

  free_and_init (scan_buffer_p->dbval_list);
  return NO_ERROR;
}

/*
 * method_scan_next_value_array () -
 *   return: int
 *   scan_buf(in)       : Value array buffer
 *   val_list(in)       :
 */
static SCAN_CODE
method_scan_next_value_array (METHOD_SCAN_BUFFER * scan_buffer_p, VAL_LIST * value_list_p)
{
  SCAN_CODE scan_result = S_SUCCESS;
  QPROC_DB_VALUE_LIST dbval_list;
  int n;

  dbval_list = scan_buffer_p->dbval_list;
  for (n = 0; n < value_list_p->val_cnt; n++)
    {
      dbval_list->next = dbval_list + 1;
      dbval_list++;
    }

  scan_buffer_p->dbval_list[value_list_p->val_cnt - 1].next = NULL;
  value_list_p->valp = scan_buffer_p->dbval_list;

  return scan_result;
}

/*
 * method_open_scan () -
 *   return: int
 *   scan_buf(in)       : Value array buffer
 *   list_id(in)        :
 *   method_sig_list(in): Method signature list
 */
int
method_open_scan (THREAD_ENTRY * thread_p, METHOD_SCAN_BUFFER * scan_buffer_p, qfile_list_id * list_id_p,
          method_sig_list * method_sig_list_p)
{
  int error;
  METHOD_INFO *method_ctl_p;

  method_ctl_p = &scan_buffer_p->s.method_ctl;

  method_ctl_p->list_id = list_id_p;
  method_ctl_p->method_sig_list = method_sig_list_p;

  error = method_open_value_array_scan (scan_buffer_p);
  if (error != NO_ERROR)
    {
      return error;
    }

  error = method_invoke (thread_p, scan_buffer_p);
  if (error != NO_ERROR)
    {
      (void) method_close_value_array_scan (scan_buffer_p);
      return error;
    }

  return NO_ERROR;
}

/*
 * method_close_scan () -
 *   return: int
 *   scan_buf(in)       : Value array buffer
 */
int
method_close_scan (THREAD_ENTRY * thread_p, METHOD_SCAN_BUFFER * scan_buffer_p)
{
#ifdef SERVER_MODE
  VACOMM_BUFFER *vacomm_buffer_p;

  /*
   * If the method scan is being closed before the client is done, the status could be zero (1st buffer not received)
   * or METHOD_SUCCESS (last buffer not received). */

  vacomm_buffer_p = scan_buffer_p->vacomm_buffer;

  if ((vacomm_buffer_p) && ((vacomm_buffer_p->status == 0) || (vacomm_buffer_p->status == METHOD_SUCCESS)))
    {
      vacomm_buffer_p->action = VACOMM_BUFFER_ABORT;

      do
    {
      (void) method_receive_results (thread_p, scan_buffer_p);
    }
      while (vacomm_buffer_p->status == METHOD_SUCCESS);
    }
#else /* SERVER_MODE */
  method_clear_scan_buffer (scan_buffer_p);
#endif /* SERVER_MODE */

  return method_close_value_array_scan (scan_buffer_p);
}

/*
 * method_scan_next () -
 *   return: int
 *   scan_buf(in)       : Value array buffer
 *   val_list(in)       :
 */
SCAN_CODE
method_scan_next (THREAD_ENTRY * thread_p, METHOD_SCAN_BUFFER * scan_buffer_p, val_list_node * value_list_p)
{
  SCAN_CODE scan_result;

  scan_result = method_receive_results (thread_p, scan_buffer_p);

  if (scan_result == S_SUCCESS)
    {
      value_list_p->val_cnt = scan_buffer_p->s.method_ctl.method_sig_list->num_methods;
      scan_result = method_scan_next_value_array (scan_buffer_p, value_list_p);
    }

  return scan_result;
}

#ifdef SERVER_MODE
static int
method_invoke_from_server (THREAD_ENTRY * thread_p, METHOD_SCAN_BUFFER * scan_buffer_p)
{
  METHOD_INFO *method_ctl_p;

  method_ctl_p = &scan_buffer_p->s.method_ctl;
  return xs_send_method_call_info_to_client (thread_p, method_ctl_p->list_id, method_ctl_p->method_sig_list);
}
#else
static int
method_invoke_from_stand_alone (METHOD_SCAN_BUFFER * scan_buffer_p)
{
  int meth_num;
  int val_cnt;
  int i;
  METHOD_INFO *method_ctl_p;
  METHOD_SIG_LIST *method_sig_list;
  METHOD_SIG *meth_sig;

  method_ctl_p = &scan_buffer_p->s.method_ctl;
  method_sig_list = method_ctl_p->method_sig_list;
  scan_buffer_p->crs_id.buffer = NULL;

  val_cnt = 0;
  meth_sig = method_sig_list->method_sig;

  for (meth_num = 0; meth_num < method_sig_list->num_methods; meth_num++)
    {
      val_cnt += meth_sig->num_method_args + 1;
      meth_sig = meth_sig->next;
    }

  if (method_ctl_p->list_id->type_list.type_cnt > val_cnt)
    {
      val_cnt = method_ctl_p->list_id->type_list.type_cnt;
    }

  scan_buffer_p->val_cnt = val_cnt;
  scan_buffer_p->vallist = (DB_VALUE *) malloc (sizeof (DB_VALUE) * val_cnt);

  if ((val_cnt > 0) && (scan_buffer_p->vallist == NULL))
    {
      return ER_FAILED;
    }
  /*
   * Make sure that these containers get initialized with meaningful
   * bits.  It's possible to wind up in method_clear_scan_buffer() without ever
   * having actually received any method results, and if that happens
   * we'll be trying to db_value_clear() junk unless we initialize things
   * here.
   */
  for (i = 0; i < val_cnt; i++)
    {
      db_make_null (&scan_buffer_p->vallist[i]);
    }

  scan_buffer_p->valptrs = (DB_VALUE **) malloc (sizeof (DB_VALUE *) * (val_cnt + 1));

  if (scan_buffer_p->valptrs == NULL)
    {
      method_clear_scan_buffer (scan_buffer_p);
      return ER_FAILED;
    }

  scan_buffer_p->oid_cols = (int *) malloc (sizeof (int) * method_sig_list->num_methods);

  if (scan_buffer_p->oid_cols == NULL)
    {
      method_clear_scan_buffer (scan_buffer_p);
      return ER_FAILED;
    }

  meth_sig = method_sig_list->method_sig;
  for (meth_num = 0; meth_num < method_sig_list->num_methods; meth_num++)
    {
      scan_buffer_p->oid_cols[meth_num] = meth_sig->method_arg_pos[0];
      meth_sig = meth_sig->next;
    }

  if (!cursor_open (&scan_buffer_p->crs_id, method_ctl_p->list_id, false, false))
    {
      method_clear_scan_buffer (scan_buffer_p);
      return ER_FAILED;
    }

  /* tfile_vfid pointer as query id for method scan */
  scan_buffer_p->crs_id.query_id = (QUERY_ID) method_ctl_p->list_id->tfile_vfid;

  cursor_set_oid_columns (&scan_buffer_p->crs_id, scan_buffer_p->oid_cols, method_sig_list->num_methods);

  return NO_ERROR;
}
#endif

/*
 * method_invoke () -
 *   return: int
 *   scan_buf(in)       : Value array buffer
 */
static int
method_invoke (THREAD_ENTRY * thread_p, METHOD_SCAN_BUFFER * scan_buffer_p)
{
#if defined(SERVER_MODE)
  return method_invoke_from_server (thread_p, scan_buffer_p);
#else /* SERVER_MODE */
  return method_invoke_from_stand_alone (scan_buffer_p);
#endif /* SERVER_MODE */
}

#ifdef SERVER_MODE
static SCAN_CODE
method_receive_results_for_server (THREAD_ENTRY * thread_p, METHOD_SCAN_BUFFER * scan_buffer_p)
{
  QPROC_DB_VALUE_LIST dbval_list;
  int meth_num, i;
  METHOD_SIG *meth_sig_p;
  SCAN_CODE result;
  DB_VALUE *dbval_p;
  METHOD_SIG_LIST *method_sig_list_p;

  method_sig_list_p = scan_buffer_p->s.method_ctl.method_sig_list;
  meth_sig_p = method_sig_list_p->method_sig;
  dbval_list = scan_buffer_p->dbval_list;

  for (meth_num = 0; meth_num < method_sig_list_p->num_methods; ++meth_num)
    {
      dbval_p = (DB_VALUE *) malloc (sizeof (DB_VALUE));
      dbval_list->val = dbval_p;

      if (dbval_p == NULL)
    {
      result = S_ERROR;
    }
      else
    {
      db_make_null (dbval_p);
      result = method_receive_value (thread_p, dbval_p, scan_buffer_p->vacomm_buffer);
    }

      if (result != S_SUCCESS)
    {
      for (i = 0; i <= meth_num; i++)
        {
          if (scan_buffer_p->dbval_list[i].val)
        {
          db_value_clear (scan_buffer_p->dbval_list[i].val);
          free_and_init (scan_buffer_p->dbval_list[i].val);
        }
        }

      if (result == S_ERROR)
        {
          scan_buffer_p->vacomm_buffer->status = METHOD_ERROR;
        }

      return result;
    }

      dbval_list++;
      meth_sig_p = meth_sig_p->next;
    }

  return S_SUCCESS;
}

#else /* SERVER_MODE */

static SCAN_CODE
method_receive_results_for_stand_alone (METHOD_SCAN_BUFFER * scan_buffer_p)
{
  QPROC_DB_VALUE_LIST dbval_list;
  int meth_num;
  METHOD_SIG *meth_sig;
  int crs_result;
  int num_args;
  int pos;
  int arg;
  int turn_on_auth = 1;
  DB_VALUE val;
  int error = NO_ERROR;
  HL_HEAPID save_pri_heap_id;
  METHOD_SIG_LIST *method_sig_list;

  method_sig_list = scan_buffer_p->s.method_ctl.method_sig_list;

  EXIT_SERVER_IN_METHOD_CALL (save_pri_heap_id);

  crs_result = cursor_next_tuple (&scan_buffer_p->crs_id);
  if (crs_result == DB_CURSOR_SUCCESS)
    {
      DB_VALUE *ptr;
      int i;

      /* Since we may be calling this in a loop, we need to clear out the vallist to avoid leaking old pointers. */
      for (i = 0, ptr = scan_buffer_p->vallist; ptr && i < scan_buffer_p->val_cnt; i++, ptr++)
    {
      pr_clear_value (ptr);
    }

      if (cursor_get_tuple_value_list (&scan_buffer_p->crs_id,
                       scan_buffer_p->s.method_ctl.list_id->type_list.type_cnt,
                       scan_buffer_p->vallist) != NO_ERROR)
    {
      method_clear_scan_buffer (scan_buffer_p);
      ENTER_SERVER_IN_METHOD_CALL (save_pri_heap_id);
      return S_ERROR;
    }

      meth_sig = method_sig_list->method_sig;
      dbval_list = scan_buffer_p->dbval_list;

      for (meth_num = 0; meth_num < method_sig_list->num_methods; meth_num++)
    {
      /* The first position # is for the object ID */
      num_args = meth_sig->num_method_args + 1;
      for (arg = 0; arg < num_args; ++arg)
        {
          pos = meth_sig->method_arg_pos[arg];
          scan_buffer_p->valptrs[arg] = &scan_buffer_p->vallist[pos];
        }

      scan_buffer_p->valptrs[num_args] = NULL;
      db_make_null (&val);

      if (meth_sig->class_name != NULL)
        {
          /* Don't call the method if the object is NULL or it has been deleted.  A method call on a NULL object is
           * NULL. */
          if (!DB_IS_NULL (scan_buffer_p->valptrs[0]))
        {
          error = db_is_any_class (db_get_object (scan_buffer_p->valptrs[0]));
          if (error == 0)
            {
              error = db_is_instance (db_get_object (scan_buffer_p->valptrs[0]));
            }
        }
          if (error == ER_HEAP_UNKNOWN_OBJECT)
        {
          error = NO_ERROR;
        }
          else if (error > 0)
        {
          /* methods must run with authorization turned on and database modifications turned off. */
          turn_on_auth = 0;
          AU_ENABLE (turn_on_auth);
          db_disable_modification ();
          ++method_Num_method_jsp_calls;
          error = obj_send_array (db_get_object (scan_buffer_p->valptrs[0]), meth_sig->method_name, &val,
                      &scan_buffer_p->valptrs[1]);
          --method_Num_method_jsp_calls;
          db_enable_modification ();
          AU_DISABLE (turn_on_auth);
        }
        }
      else
        {
          /* java stored procedure call */
          turn_on_auth = 0;
          AU_ENABLE (turn_on_auth);
          db_disable_modification ();
          ++method_Num_method_jsp_calls;
          error = jsp_call_from_server (&val, scan_buffer_p->valptrs, meth_sig->method_name,
                        meth_sig->num_method_args);
          --method_Num_method_jsp_calls;
          db_enable_modification ();
          AU_DISABLE (turn_on_auth);
        }

      if (error != NO_ERROR)
        {
          method_clear_scan_buffer (scan_buffer_p);
          ENTER_SERVER_IN_METHOD_CALL (save_pri_heap_id);
          return S_ERROR;
        }

      if (DB_VALUE_TYPE (&val) == DB_TYPE_ERROR)
        {
          if (er_errid () == NO_ERROR)
        {
          er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_GENERIC_ERROR, 1);
        }
          method_clear_scan_buffer (scan_buffer_p);
          ENTER_SERVER_IN_METHOD_CALL (save_pri_heap_id);
          return S_ERROR;
        }

      dbval_list->val = (DB_VALUE *) malloc (sizeof (DB_VALUE));
      if (dbval_list->val == NULL)
        {
          pr_clear_value (&val);
          ENTER_SERVER_IN_METHOD_CALL (save_pri_heap_id);
          return S_ERROR;
        }
      (void) db_value_domain_init (dbval_list->val, DB_TYPE_NULL, DB_DEFAULT_PRECISION, DB_DEFAULT_SCALE);

      /* Don't forget to translate any OBJECTS to OIDs. */
      if (DB_VALUE_DOMAIN_TYPE (&val) == DB_TYPE_OBJECT)
        {
          db_make_oid (dbval_list->val, ws_oid (db_get_object (&val)));
        }
      else if (db_value_clone (&val, dbval_list->val) != NO_ERROR)
        {
          pr_clear_value (&val);
          ENTER_SERVER_IN_METHOD_CALL (save_pri_heap_id);
          return S_ERROR;
        }
      pr_clear_value (&val);

      dbval_list++;
      meth_sig = meth_sig->next;
    }

      /* enter server after all jsp functions are finished */
      ENTER_SERVER_IN_METHOD_CALL (save_pri_heap_id);
      return S_SUCCESS;
    }
  else if (crs_result == DB_CURSOR_END)
    {
      method_clear_scan_buffer (scan_buffer_p);
      ENTER_SERVER_IN_METHOD_CALL (save_pri_heap_id);
      return S_END;
    }
  else
    {
      method_clear_scan_buffer (scan_buffer_p);
      ENTER_SERVER_IN_METHOD_CALL (save_pri_heap_id);
      return (SCAN_CODE) crs_result;
    }
}
#endif /* !SERVER_MODE */

/*
 * method_receive_results () -
 *   return: int
 *   scan_buf(in)       : Value array buffer
 */
static SCAN_CODE
method_receive_results (THREAD_ENTRY * thread_p, METHOD_SCAN_BUFFER * scan_buffer_p)
{
#if defined(SERVER_MODE)
  return method_receive_results_for_server (thread_p, scan_buffer_p);
#else /* SERVER_MODE */
  return method_receive_results_for_stand_alone (scan_buffer_p);
#endif /* SERVER_MODE */
}

#if !defined(SERVER_MODE)
/*
 * method_clear_scan_buffer () -
 *   return:
 *   scan_buffer_p(in)       : Value array buffer
 */
static void
method_clear_scan_buffer (METHOD_SCAN_BUFFER * scan_buffer_p)
{
  int i;
  DB_VALUE *ptr;

  if (scan_buffer_p->crs_id.buffer)
    {
      cursor_close (&scan_buffer_p->crs_id);
      scan_buffer_p->crs_id.buffer = NULL;
    }

  ptr = scan_buffer_p->vallist;
  for (i = 0; ptr && i < scan_buffer_p->val_cnt; i++)
    {
      db_value_clear (ptr);
      ptr++;
    }

  free_and_init (scan_buffer_p->valptrs);
  free_and_init (scan_buffer_p->vallist);
  free_and_init (scan_buffer_p->oid_cols);

  return;
}
#else /* !SERVER_MODE */
/*
 * method_free_vacomm_buffer () - Frees the comm buffer
 *   return:
 *   vacomm_buffer(in)  : Transmission buffer
 */
static void
method_free_vacomm_buffer (VACOMM_BUFFER * vacomm_buffer_p)
{
  if (vacomm_buffer_p)
    {
      free_and_init (vacomm_buffer_p->area);
      free_and_init (vacomm_buffer_p);
    }
}

/*
 * method_initialize_vacomm_buffer () - Initializes the method comm buffer
 *   return:
 */
static VACOMM_BUFFER *
method_initialize_vacomm_buffer (void)
{
  VACOMM_BUFFER *vacomm_buffer;

  vacomm_buffer = (VACOMM_BUFFER *) malloc (sizeof (VACOMM_BUFFER));
  if (vacomm_buffer == NULL)
    {
      er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, sizeof (VACOMM_BUFFER));
      return NULL;
    }

  vacomm_buffer->length = 0;
  vacomm_buffer->status = 0;
  vacomm_buffer->action = VACOMM_BUFFER_SEND;
  vacomm_buffer->error = 0;
  vacomm_buffer->num_vals = 0;
  vacomm_buffer->area = NULL;
  vacomm_buffer->buffer = NULL;
  vacomm_buffer->cur_pos = 0;
  vacomm_buffer->size = 0;

  return vacomm_buffer;
}

/*
 * method_receive_value () -
 *   return: int (number of values received)
 *   dbval(in)  : value
 *   vacomm_buffer(in)  : Transmission buffer
 *
 * Note: If there is a db_value in the transmission buffer,
 * unpack it & return 1.  Otherwise, if EOF is indicated return 0,
 * else receive the buffer from the client and then unpack
 * the value and return 1.  If an error is indicated, return -1
 * because the error has been set by the comm interface.
 */
static SCAN_CODE
method_receive_value (THREAD_ENTRY * thread_p, DB_VALUE * dbval_p, VACOMM_BUFFER * vacomm_buffer_p)
{
  int error;
  char *p;

  if (vacomm_buffer_p->cur_pos == 0)
    {
      if (vacomm_buffer_p->status == METHOD_EOF)
    {
      return S_END;
    }

      vacomm_buffer_p->status = METHOD_ERROR;

      error = xs_receive_data_from_client (thread_p, &vacomm_buffer_p->area, &vacomm_buffer_p->size);
      if (error == NO_ERROR)
    {
      vacomm_buffer_p->buffer = vacomm_buffer_p->area + VACOMM_BUFFER_HEADER_SIZE;
      p = or_unpack_int (vacomm_buffer_p->area + VACOMM_BUFFER_HEADER_LENGTH_OFFSET, &vacomm_buffer_p->length);
      p = or_unpack_int (vacomm_buffer_p->area + VACOMM_BUFFER_HEADER_STATUS_OFFSET, &vacomm_buffer_p->status);

      if (vacomm_buffer_p->status == METHOD_ERROR)
        {
          p = or_unpack_int (vacomm_buffer_p->area + VACOMM_BUFFER_HEADER_ERROR_OFFSET, &vacomm_buffer_p->error);
        }
      else
        {
          p =
        or_unpack_int (vacomm_buffer_p->area + VACOMM_BUFFER_HEADER_NO_VALS_OFFSET, &vacomm_buffer_p->num_vals);
        }

      if (vacomm_buffer_p->status == METHOD_SUCCESS)
        {
          error = xs_send_action_to_client (thread_p, (VACOMM_BUFFER_CLIENT_ACTION) vacomm_buffer_p->action);
          if (error != NO_ERROR)
        {
          return S_ERROR;
        }
        }
    }
      else
    {
      xs_send_action_to_client (thread_p, (VACOMM_BUFFER_CLIENT_ACTION) vacomm_buffer_p->action);
      return S_ERROR;
    }
    }

  if (vacomm_buffer_p->status == METHOD_ERROR)
    {
      return S_ERROR;
    }

  if (vacomm_buffer_p->num_vals > 0)
    {
      p = or_unpack_db_value (vacomm_buffer_p->buffer + vacomm_buffer_p->cur_pos, dbval_p);
      vacomm_buffer_p->cur_pos += OR_VALUE_ALIGNED_SIZE (dbval_p);
      vacomm_buffer_p->num_vals--;
    }
  else
    {
      return S_END;
    }

  if (vacomm_buffer_p->num_vals == 0)
    {
      vacomm_buffer_p->cur_pos = 0;
    }

  return S_SUCCESS;
}
#endif /* !SERVER_MODE */