Exemple #1
0
/*
 * crypt_sha_one() -
 *   return:
 *   thread_p(in):
 *   src(in): 
 *   src_len(in): 
 *   dest_len_p(out):
 * Note:
 */
int
crypt_sha_one (THREAD_ENTRY * thread_p, const char *src, int src_len, char **dest_p, int *dest_len_p)
{
  int hash_length;
  char *dest = NULL;
  char *dest_hex = NULL;
  int dest_len;
  int dest_hex_len;
  int error_status = NO_ERROR;

  assert (src != NULL);

  if (thread_p == NULL)
    {
      thread_p = thread_get_thread_entry_info ();
    }

  *dest_p = NULL;

  if (init_gcrypt () != NO_ERROR)
    {
      return ER_ENCRYPTION_LIB_FAILED;
    }

  hash_length = gcry_md_get_algo_dlen (GCRY_MD_SHA1);
  dest = (char *) db_private_alloc (thread_p, hash_length);
  if (dest == NULL)
    {
      error_status = ER_OUT_OF_VIRTUAL_MEMORY;
      goto exit_and_free;
    }

  dest_len = hash_length;
  gcry_md_hash_buffer (GCRY_MD_SHA1, dest, src, src_len);
  dest_hex = str_to_hex (thread_p, dest, dest_len, &dest_hex, &dest_hex_len);
  if (dest_hex == NULL)
    {
      error_status = ER_OUT_OF_VIRTUAL_MEMORY;
      goto exit_and_free;
    }

  *dest_p = dest_hex;
  *dest_len_p = dest_hex_len;

exit_and_free:
  if (dest != NULL)
    {
      db_private_free_and_init (thread_p, dest);
    }
  return error_status;
}
Exemple #2
0
/*
 * qst_free_class_list () - Frees the dynamic memory area used by the passed
 *                          linked list
 *   return: void
 *   class_id_list(in): list to be freed
 */
static void
stats_free_class_list (CLASS_ID_LIST * class_id_list_p)
{
  CLASS_ID_LIST *p, *next_p;

  if (class_id_list_p == NULL)
    {
      return;
    }

  for (p = class_id_list_p; p; p = next_p)
    {
      next_p = p->next;
      db_private_free_and_init (NULL, p);
    }

  class_id_list_p = NULL;
}
Exemple #3
0
/*
 * crypt_crc32() -
 *   return: error code
 *   thread_p(in):
 *   src(in): original message
 *   src_len(in): length of original message
 *   dest(out): crc32 result
 * Note:
 */
int
crypt_crc32 (THREAD_ENTRY * thread_p, const char *src, int src_len, int *dest)
{
  int hash_length;
  char *hash_result;
  int error_status = NO_ERROR;

  assert (src != NULL);

  if (thread_p == NULL)
    {
      thread_p = thread_get_thread_entry_info ();
    }

  if (init_gcrypt () != NO_ERROR)
    {
      return ER_ENCRYPTION_LIB_FAILED;
    }

  hash_length = gcry_md_get_algo_dlen (GCRY_MD_CRC32);
  hash_result = (char *) db_private_alloc (thread_p, hash_length);
  if (hash_result == NULL)
    {
      error_status = ER_OUT_OF_VIRTUAL_MEMORY;
      goto exit_and_free;
    }

  gcry_md_hash_buffer (GCRY_MD_CRC32, hash_result, src, src_len);

  *dest = htonl (*(UINT32 *) hash_result);

exit_and_free:
  if (hash_result != NULL)
    {
      db_private_free_and_init (thread_p, hash_result);
    }
  return error_status;
}
Exemple #4
0
/* remote_execute_delete_query_by_host() - reorganize sub-XASL for specified host to execute
* return: rc
*
* local_xasl(in): original XASL
* db_vals_p(in):
* dbval_count(in):
* flag (in):
* remote_host (in): specified host
*/
static int
remote_execute_delete_query_by_host (THREAD_ENTRY * thread_p,
				     XASL_NODE * local_xasl,
				     const DB_VALUE * dbvals_p,
				     int dbval_count,
				     QUERY_FLAG flag,
				     int remote_host,
				     QFILE_LIST_ID ** list_id_p)
{
  int rc = ER_FAILED;
  int no_classes = 0;
  int i, j, size, status = ER_FAILED;
  XASL_NODE *remote_xasl = NULL;
  ACCESS_SPEC_TYPE *remote_spec_list = NULL, *local_spec_list = NULL;
  ACCESS_SPEC_TYPE *remote_spec = NULL, *tmp_spec = NULL;
  OID *remote_oid = NULL;
  HFID *remote_hfid = NULL;
  int remote_spec_cnt = 0;
  int *remote_node_ids = NULL;
  char *remote_stream = NULL;
  int node_id;

  remote_xasl = (XASL_NODE *) db_private_alloc (thread_p, sizeof (XASL_NODE));
  if (remote_xasl == NULL)
    {
      er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1,
	      sizeof (XASL_NODE));
      goto end;
    }

  memcpy (remote_xasl, local_xasl, sizeof (XASL_NODE));

  remote_xasl->proc.delete_.no_classes = 0;

  /* save original XASL spec list */
  local_spec_list = local_xasl->aptr_list->spec_list;

  no_classes = local_xasl->proc.delete_.no_classes;

  remote_oid = (OID *) db_private_alloc (thread_p, no_classes * sizeof (OID));
  if (remote_oid == NULL)
    {
      er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1,
	      sizeof (OID));
      goto end;
    }

  remote_hfid =
    (HFID *) db_private_alloc (thread_p, no_classes * sizeof (HFID));
  if (remote_hfid == NULL)
    {
      er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1,
	      sizeof (HFID));
      goto end;
    }

  remote_node_ids =
    (int *) db_private_alloc (thread_p, no_classes * sizeof (int));
  if (remote_node_ids == NULL)
    {
      er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1,
	      sizeof (int));
      goto end;
    }

  memset (remote_node_ids, 0, no_classes * sizeof (int));

  remote_xasl->proc.delete_.class_oid = remote_oid;
  remote_xasl->proc.delete_.class_hfid = remote_hfid;

  /* step1: find out spec and oid/hfid to reorgnize sub-XASL for specified host */
  for (i = 0; i < no_classes; i++)
    {
      node_id = local_xasl->proc.delete_.node_ids[i];

      if (node_id != remote_host)
	{
	  continue;
	}

      /* for remote spec */
      tmp_spec = local_spec_list;
      j = no_classes - i - 1;

      while (j--)
	{
	  tmp_spec = tmp_spec->next;
	}

      remote_spec =
	(ACCESS_SPEC_TYPE *) db_private_alloc (thread_p,
					       sizeof (ACCESS_SPEC_TYPE));
      if (remote_spec == NULL)
	{
	  er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY,
		  1, sizeof (ACCESS_SPEC_TYPE));
	  goto end;
	}
      memcpy (remote_spec, tmp_spec, sizeof (ACCESS_SPEC_TYPE));

      tmp_spec = remote_spec_list;
      if (remote_spec_list)
	{
	  j = remote_spec_cnt - 1;
	  while (j--)
	    {
	      tmp_spec = tmp_spec->next;
	    }
	  tmp_spec->next = remote_spec;
	}

      remote_spec->s.cls_node.node_id = 0;

      /* for remote delete proc */
      remote_oid[remote_spec_cnt] = local_xasl->proc.delete_.class_oid[i];
      remote_hfid[remote_spec_cnt] = local_xasl->proc.delete_.class_hfid[i];

      remote_spec_cnt++;
      remote_xasl->proc.delete_.no_classes++;

      if (remote_spec_cnt == 1)
	{
	  remote_spec_list = remote_spec;
	}
    }

  i = remote_spec_cnt - 1;
  tmp_spec = remote_spec_list;

  while (i--)
    {
      tmp_spec = tmp_spec->next;
    }
  tmp_spec->next = NULL;

  remote_xasl->proc.delete_.no_classes = remote_spec_cnt;
  remote_xasl->proc.delete_.no_logging = local_xasl->proc.delete_.no_logging;
  remote_xasl->proc.delete_.node_ids = remote_node_ids;
  remote_xasl->proc.delete_.release_lock =
    local_xasl->proc.delete_.release_lock;
  remote_xasl->proc.delete_.waitsecs = local_xasl->proc.delete_.waitsecs;

  remote_xasl->aptr_list->spec_list = remote_spec_list;

  /* step 2: send to remote host */
  if (NO_ERROR !=
      xts_map_xasl_to_stream (thread_p, remote_xasl, &remote_stream, &size))
    {
      goto end;
    }

  if (NO_ERROR != remote_prepare_and_execute_query (thread_p,
						    remote_host,
						    remote_stream,
						    size,
						    dbvals_p,
						    dbval_count,
						    flag, list_id_p))
    {
      goto end;
    }

  /* step3: end query for remote host */
  remote_end_query (thread_p, remote_host, (*list_id_p)->query_id, &status);

  if (NO_ERROR != status)
    {
      rc = ER_FAILED;
      er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_REMOTE_SERVER_END_FAIL, 1,
	      node_id);
      goto end;
    }

  local_xasl->aptr_list->spec_list = local_spec_list;

  rc = NO_ERROR;

end:

  db_private_free_and_init (thread_p, remote_stream);
  db_private_free_and_init (thread_p, remote_xasl);

  while (remote_spec_list)
    {
      remote_spec = remote_spec_list->next;
      db_private_free_and_init (thread_p, remote_spec_list);
      remote_spec_list = remote_spec;
    }

  db_private_free_and_init (thread_p, remote_oid);
  db_private_free_and_init (thread_p, remote_hfid);
  db_private_free_and_init (thread_p, remote_node_ids);

  return rc;
}
Exemple #5
0
/* remote_count_star_scan() : -
 * thread_p(in):
 * xasl(in/out):
 * spec(in):
 * direction(in):
 */
static SCAN_CODE
remote_count_star_scan (THREAD_ENTRY * thread_p,
			XASL_NODE * xasl,
			ACCESS_SPEC_TYPE * spec, int direction,
			bool count_star_with_iscan_opt)
{
  int size = 0, status, error;
  SCAN_CODE retval = S_ERROR;
  char *spec_stream = NULL;
  QUERY_EXEC_PARM *query_parm = QPARM_PTR (thread_p);
  XASL_NODE *remote_xasl = NULL;
  QFILE_LIST_ID *list_id = NULL;
  DB_VALUE *tmp_ptr = NULL;
  QUERY_FLAG remote_flag = QPARM_PTR (thread_p)->flag;

  /* stage 1: remote scan and open list can. */
  if (!XASL_IS_FLAGED (spec, XASL_SPEC_VISITED))
    {
      error =
	remote_generate_count_star_xasl (thread_p, &remote_xasl, xasl, spec);
      if (NO_ERROR != error)
	{
	  goto end;
	}

      error =
	xts_map_xasl_to_stream (thread_p, remote_xasl, &spec_stream, &size);
      if (NO_ERROR != error)
	{
	  goto end;
	}

      if (IS_ASYNC_EXEC_MODE (remote_flag))
	{
	  remote_flag &= ~ASYNC_EXEC;
	}

      error = remote_prepare_and_execute_query (thread_p,
						spec->s.cls_node.
						node_id, spec_stream,
						size,
						query_parm->
						xasl_state->vd.
						dbval_ptr,
						query_parm->
						xasl_state->vd.
						dbval_cnt, remote_flag,
						&list_id);
      if (error != NO_ERROR)
	{
	  goto end;
	}

      list_id->remote_node_id = spec->s.cls_node.node_id;

      spec->s_id.scan_id =
	db_private_alloc (thread_p, sizeof (QFILE_LIST_SCAN_ID));
      if (spec->s_id.scan_id == NULL)
	{
	  er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY,
		  1, sizeof (QFILE_LIST_SCAN_ID));
	  goto end;
	}

      if (qfile_open_list_scan (list_id, spec->s_id.scan_id) != NO_ERROR)
	{
	  goto end;
	}

      XASL_SET_FLAG (spec, XASL_SPEC_VISITED);

      retval =
	qfile_to_val_list (thread_p, spec->s_id.scan_id, xasl->val_list);
      if (retval == S_ERROR)
	{
	  goto end;
	}
      spec->s_id.scan_id->position = S_AFTER;
      spec->s_id.scan_id->curr_vpid.pageid = NULL_PAGEID;

    }

  if (db_get_int (xasl->val_list->valp->val) > 0)
    {
      if (count_star_with_iscan_opt)
	{
	  (&xasl->curr_spec->s_id)->s.isid.oid_list.oid_cnt =
	    db_get_int (xasl->val_list->valp->val);
	  db_make_int (xasl->val_list->valp->val, 0);
	}
      else
	{
	  db_make_int (xasl->val_list->valp->val,
		       db_get_int (xasl->val_list->valp->val) - 1);
	}

      return S_SUCCESS;
    }
  else
    {
      retval = S_END;
      remote_end_query (thread_p,
			spec->s_id.scan_id->list_id.remote_node_id,
			spec->s_id.scan_id->list_id.query_id, &status);
      if (NO_ERROR != status)
	{
	  retval = S_ERROR;
	  er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_REMOTE_SERVER_END_FAIL,
		  1, spec->s.cls_node.node_id);
	}
    }

end:


  if (spec->s_id.scan_id)
    {
      if (spec->s_id.scan_id->curr_pgptr)
	{
	  free_and_init (spec->s_id.scan_id->curr_pgptr);
	}
      qfile_close_scan (thread_p, spec->s_id.scan_id);
      db_private_free_and_init (thread_p, spec->s_id.scan_id);
    }

  if (remote_xasl)
    {
      db_private_free_and_init (thread_p, remote_xasl->list_id);
      db_private_free_and_init (thread_p, remote_xasl->spec_list);
    }

  db_private_free_and_init (thread_p, remote_xasl);
  db_private_free_and_init (thread_p, spec_stream);

  if (list_id)
    {
      qfile_free_list_id (list_id);
      list_id = NULL;
    }

  return retval;
}
Exemple #6
0
/* remote_scan_next_scan() : -
 * thread_p(in):
 * xasl(in/out):
 * spec(in):
 * direction(in):
 */
static SCAN_CODE
remote_scan_next_scan (THREAD_ENTRY * thread_p,
		       XASL_NODE * xasl,
		       ACCESS_SPEC_TYPE * spec, int direction)
{
  int size = 0, status, error;
  SCAN_CODE retval = S_ERROR;
  char *spec_stream = NULL;
  QUERY_EXEC_PARM *query_parm = QPARM_PTR (thread_p);
  XASL_NODE *remote_xasl = NULL;
  QFILE_LIST_ID *list_id = NULL;
  DB_VALUE *tmp_ptr = NULL;
  QUERY_FLAG remote_flag = QPARM_PTR (thread_p)->flag;
  ACCESS_SPEC_TYPE *tmp_spec = NULL;

  /* stage 1: remote scan and open list can. */
  if (spec->s_id.scan_id == NULL)
    {
      if (XASL_IS_FLAGED (spec, XASL_SPEC_VISITED))
	{
	  return S_END;
	}

      error =
	remote_generate_remote_xasl_by_host (thread_p, &remote_xasl, xasl,
					     spec->s.cls_node.node_id);
      if (NO_ERROR != error)
	{
	  goto end;
	}

      if (xasl->type == BUILDVALUE_PROC && xasl->val_list->valp == NULL)
	{
	  remote_xasl->val_list->valp =
	    db_private_alloc (thread_p, sizeof (QPROC_DB_VALUE_LIST));
	  remote_xasl->val_list->valp->val =
	    remote_xasl->outptr_list->valptrp->value.value.dbvalptr;
	  remote_xasl->val_list->valp->next = NULL;
	  remote_xasl->val_list->val_cnt = 1;
	}
      QEXEC_REMOTE_OUTPTR_LIST (remote_xasl, &tmp_ptr);

      error =
	xts_map_xasl_to_stream (thread_p, remote_xasl, &spec_stream, &size);
      if (NO_ERROR != error)
	{
	  goto end;
	}

      QEXEC_LOCAL_OUTPTR_LIST (remote_xasl, tmp_ptr);

      if (IS_ASYNC_EXEC_MODE (remote_flag))
	{
	  remote_flag &= ~ASYNC_EXEC;
	}

      error = remote_prepare_and_execute_query (thread_p,
						spec->s.cls_node.
						node_id, spec_stream,
						size,
						query_parm->
						xasl_state->vd.
						dbval_ptr,
						query_parm->
						xasl_state->vd.
						dbval_cnt, remote_flag,
						&list_id);
      if (error != NO_ERROR)
	{
	  er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE,
		  ER_REMOTE_SERVER_SCAN_FAIL, 1, spec->s.cls_node.node_id);
	  qmgr_set_query_error (thread_p, query_parm->xasl_state->query_id);

	  goto end;
	}

      list_id->remote_node_id = spec->s.cls_node.node_id;

      spec->s_id.scan_id =
	db_private_alloc (thread_p, sizeof (QFILE_LIST_SCAN_ID));
      if (spec->s_id.scan_id == NULL)
	{
	  er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY,
		  1, sizeof (QFILE_LIST_SCAN_ID));
	  goto end;
	}

      if (qfile_open_list_scan (list_id, spec->s_id.scan_id) != NO_ERROR)
	{
	  goto end;
	}

      XASL_SET_FLAG (spec, XASL_SPEC_VISITED);
    }

  /* stage 2 : do next scan */
  retval = qfile_to_val_list (thread_p, spec->s_id.scan_id, xasl->val_list);

  /* stage 3 : close scan and send NET_SERVER_QM_QUERY_END to service node */
  if (retval == S_SUCCESS)
    {
      return retval;
    }
  else if (retval == S_END)
    {
      remote_end_query (thread_p,
			spec->s_id.scan_id->list_id.remote_node_id,
			spec->s_id.scan_id->list_id.query_id, &status);
      if (NO_ERROR != status)
	{
	  retval = S_ERROR;
	  er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_REMOTE_SERVER_END_FAIL,
		  1, spec->s.cls_node.node_id);
	}
    }

end:

  if (spec->s_id.scan_id)
    {
      qfile_close_scan (thread_p, spec->s_id.scan_id);
      db_private_free_and_init (thread_p, spec->s_id.scan_id);
    }

  if (remote_xasl)
    {
      db_private_free_and_init (thread_p, remote_xasl->list_id);

      while (remote_xasl->spec_list)
	{
	  tmp_spec = remote_xasl->spec_list->next;
	  db_private_free_and_init (thread_p, remote_xasl->spec_list);
	  remote_xasl->spec_list = tmp_spec;
	}
    }

  db_private_free_and_init (thread_p, remote_xasl);
  db_private_free_and_init (thread_p, spec_stream);

  if (list_id)
    {
      qfile_free_list_id (list_id);
      list_id = NULL;
    }

  return retval;
}
Exemple #7
0
/*
 * xlogwr_get_log_pages -
 *
 * return:
 *
 *   thread_p(in):
 *   first_pageid(in):
 *   mode(in):
 *
 * Note:
 */
int
xlogwr_get_log_pages (THREAD_ENTRY * thread_p, PAGEID first_pageid, int mode)
{
  LOGWR_ENTRY *entry;
  char *logpg_area;
  int logpg_used_size;
  PAGEID next_fpageid;
  LOGWR_MODE next_mode;
  int status;
  int rv;
  int error_code;
  bool check_cs_own = false;
  LOGWR_INFO *writer_info = &log_Gl.writer_info;

  logpg_used_size = 0;
  logpg_area = db_private_alloc (thread_p, PRM_LOG_NBUFFERS * LOG_PAGESIZE);
  if (logpg_area == NULL)
    {
      error_code = ER_OUT_OF_VIRTUAL_MEMORY;
      er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1,
	      PRM_LOG_NBUFFERS * LOG_PAGESIZE);
      return ER_OUT_OF_VIRTUAL_MEMORY;
    }

  if (thread_p->conn_entry)
    {
      thread_p->conn_entry->stop_phase = THREAD_WORKER_STOP_PHASE_1;
    }

  while (true)
    {
      er_log_debug (ARG_FILE_LINE,
		    "[tid:%ld] xlogwr_get_log_pages, fpageid(%d), mode(%s)\n",
		    thread_p->tid, first_pageid,
		    (mode == LOGWR_MODE_SYNC ? "sync" :
		     (mode == LOGWR_MODE_ASYNC ? "async" : "semisync")));

      /* Register the writer at the list and wait until LFT start to work */
      LOG_MUTEX_LOCK (rv, writer_info->flush_start_mutex);
      error_code = logwr_register_writer_entry (&entry, thread_p,
						first_pageid, mode);
      if (error_code != NO_ERROR)
	{
	  LOG_MUTEX_UNLOCK (writer_info->flush_start_mutex);
	  status = LOGWR_STATUS_ERROR;
	  goto error;
	}

      if (entry->status == LOGWR_STATUS_WAIT)
	{
	  bool continue_checking = true;

	  thread_suspend_with_other_mutex (thread_p,
					   &writer_info->flush_start_mutex,
					   INF_WAIT, NULL,
					   THREAD_LOGWR_SUSPENDED);

	  LOG_MUTEX_UNLOCK (writer_info->flush_start_mutex);

	  if (logtb_is_interrupted (thread_p, false, &continue_checking)
	      || thread_p->resume_status == THREAD_RESUME_DUE_TO_INTERRUPT)
	    {
	      /* interrupted, shutdown or connection has gone. */
	      error_code = ER_INTERRUPTED;
	      er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, error_code, 0);
	      status = LOGWR_STATUS_ERROR;
	      goto error;
	    }
	  else if (thread_p->resume_status != THREAD_LOGWR_RESUMED)
	    {
	      error_code = ER_FAILED;
	      status = LOGWR_STATUS_ERROR;
	      goto error;
	    }
	}
      else
	{
	  assert (entry->status == LOGWR_STATUS_DELAY);
	  LOG_MUTEX_UNLOCK (writer_info->flush_start_mutex);
	  LOG_CS_ENTER (thread_p);
	  check_cs_own = true;
	}

      /* Send the log pages to be flushed until now */
      error_code = logwr_pack_log_pages (thread_p, logpg_area,
					 &logpg_used_size, &status, entry);
      if (error_code != NO_ERROR)
	{
	  status = LOGWR_STATUS_ERROR;
	  goto error;
	}

      error_code = xlog_send_log_pages_to_client (thread_p, logpg_area,
						  logpg_used_size, mode);
      if (error_code != NO_ERROR)
	{
	  status = LOGWR_STATUS_ERROR;
	  goto error;
	}

      /* In case of async mode, unregister the writer and wakeup LFT to finish */
      /*
         The result mode is the following.

         transition \ req mode |  req_sync   req_async
         -----------------------------------------
         delay -> delay    |  n/a        ASYNC
         delay -> done     |  n/a        SYNC
         wait -> delay     |  SYNC       ASYNC
         wait -> done      |  SYNC       ASYNC
       */

      if (mode == LOGWR_MODE_ASYNC
	  && (entry->status != LOGWR_STATUS_DELAY
	      || (entry->status == LOGWR_STATUS_DELAY
		  && status != LOGWR_STATUS_DONE)))
	{
	  if (check_cs_own)
	    {
	      check_cs_own = false;
	      LOG_CS_EXIT ();
	    }
	  LOG_MUTEX_LOCK (rv, writer_info->flush_end_mutex);
	  if (logwr_unregister_writer_entry (entry, status))
	    {
	      COND_SIGNAL (writer_info->flush_end_cond);
	    }
	  LOG_MUTEX_UNLOCK (writer_info->flush_end_mutex);
	}

      /* Get the next request from the client and reset the arguments */
      error_code = xlog_get_page_request_with_reply (thread_p, &next_fpageid,
						     &next_mode);
      if (error_code != NO_ERROR)
	{
	  status = LOGWR_STATUS_ERROR;
	  goto error;
	}

      /* In case of sync mode, unregister the writer and wakeup LFT to finish */
      if (mode != LOGWR_MODE_ASYNC
	  || (entry->status == LOGWR_STATUS_DELAY
	      && status == LOGWR_STATUS_DONE))
	{
	  if (check_cs_own)
	    {
	      check_cs_own = false;
	      LOG_CS_EXIT ();
	    }
	  LOG_MUTEX_LOCK (rv, writer_info->flush_end_mutex);
	  if (logwr_unregister_writer_entry (entry, status))
	    {
	      COND_SIGNAL (writer_info->flush_end_cond);
	    }
	  LOG_MUTEX_UNLOCK (writer_info->flush_end_mutex);
	}

      /* Reset the arguments for the next request */
      first_pageid = next_fpageid;
      mode = next_mode;
    }

  db_private_free_and_init (thread_p, logpg_area);

  return NO_ERROR;

error:

  er_log_debug (ARG_FILE_LINE,
		"[tid:%ld] xlogwr_get_log_pages, error(%d)\n",
		thread_p->tid, error_code);
  if (check_cs_own)
    {
      LOG_CS_EXIT ();
    }
  LOG_MUTEX_LOCK (rv, writer_info->flush_end_mutex);
  if (entry != NULL && logwr_unregister_writer_entry (entry, status))
    {
      COND_SIGNAL (writer_info->flush_end_cond);
    }
  LOG_MUTEX_UNLOCK (writer_info->flush_end_mutex);

  db_private_free_and_init (thread_p, logpg_area);

  return error_code;
}
Exemple #8
0
/*
 * crypt_sha_two() -
 *   return:
 *   thread_p(in):
 *   src(in):
 *   src_len(in):
 *   need_hash_len(in):
 *   dest_p(out)
 *   dest_len_p(out):
 * Note:
 */
int
crypt_sha_two (THREAD_ENTRY * thread_p, const char *src, int src_len, int need_hash_len, char **dest_p, int *dest_len_p)
{
  int hash_length;
  int algo;
  char *dest = NULL;
  int dest_len;
  char *dest_hex = NULL;
  int dest_hex_len;
  int error_status = NO_ERROR;

  assert (src != NULL);

  if (thread_p == NULL)
    {
      thread_p = thread_get_thread_entry_info ();
    }

  *dest_p = NULL;

  switch (need_hash_len)
    {
    case 0:
    case 256:
      algo = GCRY_MD_SHA256;
      break;
    case 224:
      algo = GCRY_MD_SHA224;
      break;
    case 384:
      algo = GCRY_MD_SHA384;
      break;
    case 512:
      algo = GCRY_MD_SHA512;
      break;
    default:
      return NO_ERROR;
    }

  if (init_gcrypt () != NO_ERROR)
    {
      return ER_ENCRYPTION_LIB_FAILED;
    }

  hash_length = gcry_md_get_algo_dlen (algo);
  dest_len = hash_length;
  dest = (char *) db_private_alloc (thread_p, hash_length);
  if (dest == NULL)
    {
      error_status = ER_OUT_OF_VIRTUAL_MEMORY;
      goto exit_and_free;
    }

  gcry_md_hash_buffer (algo, dest, src, src_len);
  dest_hex = str_to_hex (thread_p, dest, dest_len, &dest_hex, &dest_hex_len);
  if (dest_hex == NULL)
    {
      error_status = ER_OUT_OF_VIRTUAL_MEMORY;
      goto exit_and_free;
    }

  *dest_p = dest_hex;
  *dest_len_p = dest_hex_len;

exit_and_free:
  if (dest != NULL)
    {
      db_private_free_and_init (thread_p, dest);
    }
  return error_status;
}
Exemple #9
0
/*
 * crypt_aes_default_decrypt() - like mysql's aes_decrypt. Use AES-128/ECB/PKCS7 method.
 *   return:
 *   thread_p(in):
 *   src(in): source string
 *   src_len(in): the length of source string
 *   key(in): the encrypt key
 *   key_len(in): the length of the key
 *   dest_p(out): the encrypted data. The pointer has to be free by db_private_free
 *   dest_len_p(out):
 * Note:
 */
int
crypt_aes_default_decrypt (THREAD_ENTRY * thread_p, const char *src, int src_len, const char *key, int key_len,
			   char **dest_p, int *dest_len_p)
{
  gcry_error_t i_gcrypt_err;
  gcry_cipher_hd_t aes_ctx;
  char *dest = NULL;
  int dest_len = 0;
  char new_key[AES128_KEY_LEN];
  int pad, pad_len;
  int i;
  int error_status = NO_ERROR;

  assert (src != NULL);
  assert (key != NULL);

  if (thread_p == NULL)
    {
      thread_p = thread_get_thread_entry_info ();
    }

  *dest_p = NULL;
  *dest_len_p = 0;

  /* src is not a string encrypted by aes_default_encrypt, return NULL */
  if (src_len % AES128_BLOCK_LEN)
    {
      return NO_ERROR;
    }

  if (init_gcrypt () != NO_ERROR)
    {
      return ER_ENCRYPTION_LIB_FAILED;
    }

  i_gcrypt_err = gcry_cipher_open (&aes_ctx, GCRY_CIPHER_AES, GCRY_CIPHER_MODE_ECB, 0);
  if (i_gcrypt_err != GPG_ERR_NO_ERROR)
    {
      er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_ENCRYPTION_LIB_FAILED, 1,
	      crypt_lib_fail_info[CRYPT_LIB_OPEN_CIPHER_ERR]);
      return ER_ENCRYPTION_LIB_FAILED;
    }

  dest = (char *) db_private_alloc (thread_p, src_len * sizeof (char));
  if (dest == NULL)
    {
      error_status = ER_OUT_OF_VIRTUAL_MEMORY;
      goto error_and_free;
    }

  aes_default_gen_key (key, key_len, new_key, AES128_KEY_LEN);
  i_gcrypt_err = gcry_cipher_setkey (aes_ctx, new_key, AES128_KEY_LEN);
  if (i_gcrypt_err != GPG_ERR_NO_ERROR)
    {
      er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_ENCRYPTION_LIB_FAILED, 1,
	      crypt_lib_fail_info[CRYPT_LIB_SET_KEY_ERR]);
      error_status = ER_ENCRYPTION_LIB_FAILED;
      goto error_and_free;
    }

  i_gcrypt_err = gcry_cipher_decrypt (aes_ctx, dest, src_len, src, src_len);
  if (i_gcrypt_err != GPG_ERR_NO_ERROR)
    {
      error_status = ER_ENCRYPTION_LIB_FAILED;
      er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_ENCRYPTION_LIB_FAILED, 1, crypt_lib_fail_info[CRYPT_LIB_CRYPT_ERR]);
      goto error_and_free;
    }

  /* PKCS7 */
  if (src_len != 0)
    {
      pad = dest[src_len - 1];
      if (pad > AES128_BLOCK_LEN)
	{
	  /* src is not a string encrypted by aes_default_encrypt, return NULL */
	  if (dest != NULL)
	    {
	      db_private_free_and_init (thread_p, dest);
	    }
	  goto error_and_free;
	}
      i = src_len - 2;
      pad_len = 1;
      while ((i >= 0) && (dest[i] == pad))
	{
	  pad_len++;
	  i--;
	}
      if ((pad_len >= pad))
	{
	  pad_len = pad;
	  dest_len = src_len - pad_len;
	}
      else
	{
	  /* src is not a string encrypted by aes_default_encrypt, return NULL */
	  if (dest != NULL)
	    {
	      db_private_free_and_init (thread_p, dest);
	    }
	  goto error_and_free;
	}
    }

  *dest_p = dest;
  *dest_len_p = dest_len;

error_and_free:
  if ((dest != NULL) && (error_status != NO_ERROR))
    {
      db_private_free_and_init (thread_p, dest);
    }
  gcry_cipher_close (aes_ctx);
  return error_status;
}
Exemple #10
0
/*
 * crypt_aes_default_encrypt() - like mysql's aes_encrypt. Use AES-128/ECB/PKCS7 method.
 *   return:
 *   thread_p(in):
 *   src(in): source string
 *   src_len(in): the length of source string
 *   key(in): the encrypt key
 *   key_len(in): the length of the key
 *   dest_p(out): the encrypted data. The pointer has to be free by db_private_free
 *   dest_len_p(out):
 * Note:
 */
int
crypt_aes_default_encrypt (THREAD_ENTRY * thread_p, const char *src, int src_len, const char *key, int key_len,
			   char **dest_p, int *dest_len_p)
{
  gcry_error_t i_gcrypt_err;
  gcry_cipher_hd_t aes_ctx;
  char new_key[AES128_KEY_LEN];
  int pad;
  int padding_src_len;
  char *padding_src = NULL;
  char *dest = NULL;
  int error_status = NO_ERROR;

  assert (src != NULL);
  assert (key != NULL);

  if (thread_p == NULL)
    {
      thread_p = thread_get_thread_entry_info ();
    }

  *dest_p = NULL;
  *dest_len_p = 0;

  if (init_gcrypt () != NO_ERROR)
    {
      return ER_ENCRYPTION_LIB_FAILED;
    }

  i_gcrypt_err = gcry_cipher_open (&aes_ctx, GCRY_CIPHER_AES, GCRY_CIPHER_MODE_ECB, 0);
  if (i_gcrypt_err != GPG_ERR_NO_ERROR)
    {
      er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_ENCRYPTION_LIB_FAILED, 1,
	      crypt_lib_fail_info[CRYPT_LIB_OPEN_CIPHER_ERR]);
      return ER_ENCRYPTION_LIB_FAILED;
    }

  /* PKCS7 */
  if ((src_len % AES128_BLOCK_LEN) == 0)
    {
      pad = AES128_BLOCK_LEN;
      padding_src_len = src_len + pad;
    }
  else
    {
      padding_src_len = ceil ((double) src_len / AES128_BLOCK_LEN) * AES128_BLOCK_LEN;
      pad = padding_src_len - src_len;
    }

  padding_src = (char *) db_private_alloc (thread_p, padding_src_len);
  if (padding_src == NULL)
    {
      error_status = ER_OUT_OF_VIRTUAL_MEMORY;
      goto exit_and_free;
    }
  memcpy (padding_src, src, src_len);
  memset (padding_src + src_len, pad, pad);

  aes_default_gen_key (key, key_len, new_key, AES128_KEY_LEN);
  i_gcrypt_err = gcry_cipher_setkey (aes_ctx, new_key, AES128_KEY_LEN);
  if (i_gcrypt_err != GPG_ERR_NO_ERROR)
    {
      error_status = ER_ENCRYPTION_LIB_FAILED;
      er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_ENCRYPTION_LIB_FAILED, 1,
	      crypt_lib_fail_info[CRYPT_LIB_SET_KEY_ERR]);
      goto exit_and_free;
    }

  dest = (char *) db_private_alloc (thread_p, padding_src_len);
  if (dest == NULL)
    {
      error_status = ER_OUT_OF_VIRTUAL_MEMORY;
      goto exit_and_free;
    }

  i_gcrypt_err = gcry_cipher_encrypt (aes_ctx, dest, padding_src_len, padding_src, padding_src_len);
  if (i_gcrypt_err != GPG_ERR_NO_ERROR)
    {
      er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_ENCRYPTION_LIB_FAILED, 1, crypt_lib_fail_info[CRYPT_LIB_CRYPT_ERR]);
      error_status = ER_ENCRYPTION_LIB_FAILED;
      goto exit_and_free;
    }

  *dest_len_p = padding_src_len;
  *dest_p = dest;

exit_and_free:
  if (padding_src != NULL)
    {
      db_private_free_and_init (thread_p, padding_src);
    }
  if ((dest != NULL) && (error_status != NO_ERROR))
    {
      db_private_free_and_init (thread_p, dest);
    }
  gcry_cipher_close (aes_ctx);
  return error_status;
}