VOID
Hvl11Free(
    _In_ _Post_ptr_invalid_  PHVL pHvl
    )
{
    if (NULL != pHvl)
    {
        HvlWaitForPendingThreads(pHvl);
        
        NdisFreeSpinLock(&(pHvl->Lock));
        
        if (pHvl->CtxSWorkItemHandle)
        {
            NdisFreeIoWorkItem(pHvl->CtxSWorkItemHandle);
        }
        
        if (pHvl->NotificationsWorkItemHandle)
        {
            NdisFreeIoWorkItem(pHvl->NotificationsWorkItemHandle);
        }

        if (pHvl->pPnpOpExReq)
        {
            FREE_MEM(pHvl->pPnpOpExReq);
        }

        // free the memory allocated for any pending operations
        HvlDeleteAllPendingOperations(pHvl);
        
        FREE_MEM(pHvl);
    }
}

bool MVMul()
{
	bool bRtn = false;
	double	i, j;

	if (0 == g_matrix.fRowCount || 0 == g_matrix.fColumnCount || 0 == g_vector_input.fRowCount || g_vector_input.fRowCount != g_matrix.fColumnCount)
		return bRtn;

	g_vector_output.fRowCount = g_matrix.fRowCount;
	g_vector_output.pfReal = (double*)malloc(sizeof(double)*g_vector_output.fRowCount);
	g_vector_output.pfImaginary = (double*)malloc(sizeof(double)*g_vector_output.fRowCount);

	if (NULL == g_vector_output.pfReal || NULL == g_vector_output.pfImaginary)
	{
		FREE_MEM(g_vector_output.pfReal);
		FREE_MEM(g_vector_output.pfImaginary);
		return bRtn;
	}

	for (i = 0; i < g_matrix.fRowCount; ++i)
	{
		g_vector_output.pfReal[(int)i] = 0.;
		g_vector_output.pfImaginary[(int)i] = 0.;
		for (j = 0; j < g_matrix.fColumnCount; ++j)
		{
			double		fMatrixReal = g_matrix.pfReal[(int)i*(int)g_matrix.fColumnCount + (int)j];
			double		fMatrixImaginary = g_matrix.pfImaginary[(int)i*(int)g_matrix.fColumnCount + (int)j];
			g_vector_output.pfReal[(int)i] += fMatrixReal * g_vector_input.pfReal[(int)j] - fMatrixImaginary * g_vector_input.pfImaginary[(int)j];
			g_vector_output.pfImaginary[(int)i] += fMatrixReal * g_vector_input.pfImaginary[(int)j] + fMatrixImaginary * g_vector_input.pfReal[(int)j];
		}
	}

	bRtn = true;
	return bRtn;
}

void
hm_req_handle_fetch_buf_free (T_REQ_HANDLE * req_handle)
{
  int i, j, fetched_tuple;

  if (req_handle->tuple_value)
    {
      fetched_tuple = req_handle->fetched_tuple_end -
	req_handle->fetched_tuple_begin + 1;
      for (i = 0; i < fetched_tuple; i++)
	{
#if defined(WINDOWS)
	  for (j = 0; j < req_handle->num_col_info; j++)
	    {
	      FREE_MEM (req_handle->tuple_value[i].decoded_ptr[j]);
	    }

	  FREE_MEM (req_handle->tuple_value[i].decoded_ptr);
#endif
	  FREE_MEM (req_handle->tuple_value[i].column_ptr);
	}
      FREE_MEM (req_handle->tuple_value);
    }
  FREE_MEM (req_handle->msg_buf);
  req_handle->fetched_tuple_begin = req_handle->fetched_tuple_end = 0;
  req_handle->cur_fetch_tuple_index = -1;
  req_handle->is_fetch_completed = 0;
}

void
query_info_clear (T_QUERY_INFO * qi)
{
  FREE_MEM (qi->sql);
  FREE_MEM (qi->cas_log);
  qi->start_date[0] = '\0';
}

*/	int OS_Browse(REBCHR *url, int reserved)
/*
***********************************************************************/
{
	#define MAX_BRW_PATH 2044
	long flag;
	long len;
	long type;
	HKEY key;
	REBCHR *path;
	HWND hWnd = GetFocus();

	if (RegOpenKeyEx(HKEY_CLASSES_ROOT, TEXT("http\\shell\\open\\command"), 0, KEY_READ, &key) != ERROR_SUCCESS)
		return 0;

	if (!url) url = TEXT("");

	path = MAKE_STR(MAX_BRW_PATH+4);
	len = MAX_BRW_PATH;

	flag = RegQueryValueEx(key, TEXT(""), 0, &type, (LPBYTE)path, &len);
	RegCloseKey(key);
	if (flag != ERROR_SUCCESS) {
		FREE_MEM(path);
		return 0;
	}
	//if (ExpandEnvironmentStrings(&str[0], result, len))

	Insert_Command_Arg(path, url, MAX_BRW_PATH);

	len = OS_Create_Process(path, 0);

	FREE_MEM(path);
	return len;
}

static void *
extract_host_partition_stat (FILE * fp, const char *arg1,
			     T_CM_ERROR * err_buf)
{
  char linebuf[LINE_MAX];
  char type[512];
  int nitem = 0;
  int nalloc = 10;
  T_CM_DISK_PARTITION_STAT *p = NULL;
  T_CM_DISK_PARTITION_STAT_ALL *stat = NULL;

  stat =
    (T_CM_DISK_PARTITION_STAT_ALL *)
    malloc (sizeof (T_CM_DISK_PARTITION_STAT_ALL));
  p =
    (T_CM_DISK_PARTITION_STAT *) malloc (nalloc *
					 sizeof (T_CM_DISK_PARTITION_STAT));
  if (stat == NULL || p == NULL)
    {
      cm_set_error (err_buf, CM_OUT_OF_MEMORY);
      FREE_MEM (stat);
      FREE_MEM (p);
      return NULL;
    }
  stat->partitions = p;

  while (fgets (linebuf, sizeof (linebuf), fp))
    {
      sscanf (linebuf, "%*s%511s", type);
      if (strstr (type, "ext") == NULL)
	continue;

      if (nitem >= nalloc)
	{
	  nalloc *= 2;
	  stat->partitions =
	    realloc (stat->partitions,
		     nalloc * sizeof (T_CM_DISK_PARTITION_STAT));
	}
      if (stat->partitions)
	{
	  p = stat->partitions + nitem;
	  sscanf (linebuf, "%255s%*s%llu%llu%llu", p->name, &p->size,
		  &p->used, &p->avail);
	  nitem++;
	}
      else
	{
	  cm_host_disk_partition_stat_free (stat);
	  cm_set_error (err_buf, CM_OUT_OF_MEMORY);
	  return NULL;
	}
    }
  stat->num_stat = nitem;

  return stat;
}

void
cm_db_proc_stat_all_free (T_CM_DB_PROC_STAT_ALL * stat)
{
  if (stat != NULL)
    {
      FREE_MEM (stat->db_stats);
      FREE_MEM (stat);
    }
}

void
cm_host_disk_partition_stat_free (T_CM_DISK_PARTITION_STAT_ALL * stat)
{
  if (stat != NULL)
    {
      FREE_MEM (stat->partitions);
      FREE_MEM (stat);
    }
}

int CMPIPTV_RTSP::SendRtspCommand(const TCHAR *method, const TCHAR *command, MediaSubsession *subsession)
{
  this->logger.Log(LOGGER_VERBOSE, _T("%s: %s: send %s command"), PROTOCOL_IMPLEMENTATION_NAME, method, command);
  ResetEvent(this->rtspResponseEvent);
  if (_tcscmp(command, _T("OPTIONS")) == 0)
  {
    this->rtspClient->sendOptionsCommand(&CMPIPTV_RTSP::OnRtspResponseReceived);
  }
  else if (_tcscmp(command, _T("DESCRIBE")) == 0)
  {
    this->rtspClient->sendDescribeCommand(&CMPIPTV_RTSP::OnRtspResponseReceived);
  }
  else if (_tcscmp(command, _T("SETUP")) == 0)
  {
    this->rtspClient->sendSetupCommand(*subsession, &CMPIPTV_RTSP::OnRtspResponseReceived);
  }
  else if (_tcscmp(command, _T("PLAY")) == 0)
  {
    this->rtspClient->sendPlayCommand(*this->rtspSession, &CMPIPTV_RTSP::OnRtspResponseReceived);
  }
  else if (_tcscmp(command, _T("TEARDOWN")) == 0)
  {
    this->rtspClient->sendTeardownCommand(*this->rtspSession, &CMPIPTV_RTSP::OnRtspResponseReceived);
  }
  else
  {
    return STATUS_ERROR;
  }

  if (WaitForSingleObject(this->rtspResponseEvent, this->rtspCommandResponseTimeout) == WAIT_TIMEOUT)
  {
    this->logger.Log(LOGGER_ERROR, _T("%s: %s: %s command timed out"), PROTOCOL_IMPLEMENTATION_NAME, method, command);
    return STATUS_ERROR;
  }
  if (this->rtspResponseResultCode != 0)
  {
#ifdef _MBCS
    TCHAR *convertedRtspResponse = ConvertToMultiByteA(&this->rtspResponseResultString[0]);
#else
    TCHAR *convertedRtspResponse = ConvertToUnicodeA(&this->rtspResponseResultString[0]);
#endif
    this->logger.Log(LOGGER_ERROR, _T("%s: %s: %s command failed, code = %i, response = %s"), PROTOCOL_IMPLEMENTATION_NAME, method, command, this->rtspResponseResultCode, (convertedRtspResponse == NULL) ? _T("unable to get message") : convertedRtspResponse);
    FREE_MEM(convertedRtspResponse);
    return STATUS_ERROR;
  }

#ifdef _MBCS
  TCHAR *convertedRtspResponse = ConvertToMultiByteA(&this->rtspResponseResultString[0]);
#else
  TCHAR *convertedRtspResponse = ConvertToUnicodeA(&this->rtspResponseResultString[0]);
#endif
  this->logger.Log(LOGGER_VERBOSE, _T("%s: %s: %s command succeeded, response = %s"), PROTOCOL_IMPLEMENTATION_NAME, method, command, (convertedRtspResponse == NULL) ? _T("unable to get message") : convertedRtspResponse);
  FREE_MEM(convertedRtspResponse);
  return STATUS_OK;
}

void
t_set_free (T_SET * set)
{
  if (set == NULL)
    return;

  FREE_MEM (set->element);
  FREE_MEM (set->data_buf);
  hm_conv_value_buf_clear (&(set->conv_value_buffer));
  FREE_MEM (set);
}

int
net_decode_str (char *msg, int msg_size, char *func_code, void ***ret_argv)
{
  int remain_size = msg_size;
  char *cur_p = msg;
  char *argp;
  int i_val;
  void **argv = NULL;
  int argc = 0;

  *ret_argv = (void **) NULL;

  if (remain_size < 1)
    return CAS_ER_COMMUNICATION;

  *func_code = *cur_p;
  cur_p += 1;
  remain_size -= 1;

  while (remain_size > 0)
    {
      if (remain_size < 4)
	{
	  FREE_MEM (argv);
	  return CAS_ER_COMMUNICATION;
	}
      argp = cur_p;
      memcpy ((char *) &i_val, cur_p, 4);
      i_val = ntohl (i_val);
      remain_size -= 4;
      cur_p += 4;

      if (remain_size < i_val)
	{
	  FREE_MEM (argv);
	  return CAS_ER_COMMUNICATION;
	}

      argc++;
      argv = (void **) REALLOC (argv, sizeof (void *) * argc);
      if (argv == NULL)
	return CAS_ER_NO_MORE_MEMORY;

      argv[argc - 1] = argp;

      cur_p += i_val;
      remain_size -= i_val;
    }

  *ret_argv = argv;
  return argc;
}

int
t_set_decode (T_SET * set)
{
  void **element;
  char *cur_p;
  int i;
  int remain_size;
  int ele_size;

  if (set->num_element < 0 || set->data_size < 0)
    return CCI_ER_COMMUNICATION;

  if (set->num_element == 0 || set->data_size == 0)
    return 0;

  element = (void **) MALLOC (sizeof (void *) * set->num_element);
  if (element == NULL)
    return CCI_ER_NO_MORE_MEMORY;
  memset (element, 0, sizeof (void *) * set->num_element);

  remain_size = set->data_size;
  cur_p = (char *) set->data_buf;

  for (i = 0; i < set->num_element; i++)
    {
      element[i] = cur_p;
      if (remain_size < 4)
	{
	  FREE_MEM (element);
	  return CCI_ER_COMMUNICATION;
	}
      NET_STR_TO_INT (ele_size, cur_p);
      cur_p += 4;
      remain_size -= 4;

      if (ele_size <= 0)
	continue;

      if (remain_size < ele_size)
	{
	  FREE_MEM (element);
	  return CCI_ER_COMMUNICATION;
	}
      cur_p += ele_size;
      remain_size -= ele_size;
    }

  set->element = element;
  return 0;
}

VOID
HvlFreeNotification(
    PHVL_NOTIFICATION pHvlNotif
    )
{
    if (pHvlNotif)
    {
        if (pHvlNotif->pvNotif)
        {
            FREE_MEM(pHvlNotif->pvNotif);
        }
        
        FREE_MEM(pHvlNotif);
    }
}

DWORD
WINAPI
WahDestroyContextTable(
    LPCONTEXT_TABLE Table
    )

/*++

Routine Description:

    Destroys an existing context table.

Arguments:

    Table - A pointer to the table to destroy.

Return Value:

    DWORD - NO_ERROR if successful, a Win32 error code if not.

--*/

{

    //
    // Delete the context table's critical section if necessary.
    //

    if( Table->Flags & WAH_CONTEXT_FLAG_SERIALIZE ) {

        DeleteCriticalSection( TABLE_TO_LOCK( Table ) );

    }

    //
    // Free the resources.
    //

    FREE_MEM( Table->LookupArray );
    FREE_MEM( Table );

    //
    // Success!
    //

    return NO_ERROR;

}   // WahDestroyContextTable

int
cm_get_db_exec_stat (const char *db_name,
		     T_CM_DB_EXEC_STAT * exec_stat, T_CM_ERROR * err_buf)
{
  T_CM_DB_EXEC_STAT *p = NULL;
  char *root_env = NULL;
  char exec_path[PATH_MAX];
  /* cubrid statdump dbname */
  const char *argv[] = {
    exec_path,
    "statdump",
    db_name,
    NULL,
  };

  cm_err_buf_reset (err_buf);
  if (db_name == NULL)
    {
      cm_set_error (err_buf, CM_ERR_NULL_POINTER);
      return -1;
    }

  (void) envvar_bindir_file (exec_path, PATH_MAX, UTIL_CUBRID);
  p = (T_CM_DB_EXEC_STAT *) cm_get_command_result (argv,
						   extract_db_exec_stat,
						   db_name, err_buf);
  if (p != NULL)
    {
      *exec_stat = *p;
      FREE_MEM (p);
      return 0;
    }
  return -1;
}

CMPIPTV_RTSP::~CMPIPTV_RTSP()
{
  this->logger.Log(LOGGER_INFO, METHOD_START_FORMAT, PROTOCOL_IMPLEMENTATION_NAME, METHOD_DESTRUCTOR_NAME);

  if (this->IsConnected())
  {
    this->CloseConnection();
  }

  if (this->rtspEnvironment != NULL)
  {
    // release RTSP environment
    this->rtspEnvironment->reclaim();
    this->rtspEnvironment = NULL;
  }

  if (this->rtspScheduler != NULL)
  {
    delete this->rtspScheduler;
    this->rtspScheduler = NULL;
  }

  FREE_MEM(this->rtspUrl);

  this->logger.Log(LOGGER_INFO, METHOD_END_FORMAT, PROTOCOL_IMPLEMENTATION_NAME, METHOD_DESTRUCTOR_NAME);
}

NDIS_STATUS 
VNic11JoinCompleteCallback(
    _In_  PVNIC                   pVNic,
    _In_  PVOID                   pvCtx,
    _In_  PVOID                   Data
    )
{
    PVNIC_COMPLETION_CTX pCtx = NULL;
    PORT11_GENERIC_CALLBACK_FUNC JoinCompleteHandler= NULL;
    NDIS_STATUS ndisStatus = NDIS_STATUS_SUCCESS;
    
    MpTrace(COMP_HVL, DBG_NORMAL, ("VNic(%d): Hw completed Join operation \n", VNIC_PORT_NO));

    pCtx = (PVNIC_COMPLETION_CTX)pvCtx;
    ASSERT(pCtx);
    
    JoinCompleteHandler = pCtx->CompletionFn;

    FREE_MEM(pCtx);

    VNicLock(pVNic);
    ndisStatus = VNicJoinComplete(pVNic, TRUE, JoinCompleteHandler, Data);    
    VNicUnlock(pVNic);

    return ndisStatus;    
}

MPIPTVSOURCE_API int SetAndCheckSocketOption(CLogger *logger, const TCHAR *protocolName, const TCHAR *functionName, const TCHAR *optionName, SOCKET s, int level, int optname, const char *optval, int optlen)
{
  int result = SetSocketOption(logger, protocolName, functionName, optionName, s, level, optname, optval, optlen);

  if (result == 0)
  {
    // option correctly set, now check it
    int valLen = optlen;
    ALLOC_MEM_DEFINE_SET(val, char, optlen, 0);
    result = (val == NULL) ? E_OUTOFMEMORY : 0;
    if (result == 0)
    {
      result = GetSocketOption(logger, protocolName, functionName, optionName, s, level, optname, val, &valLen);
      if (result == 0)
      {
        // successfully retrieved value
        if (optlen == valLen)
        {
          result = (memcmp(optval, val, optlen) == 0) ? 0 : (-1);
        }
      }
    }

    FREE_MEM(val);
  }

int main(int argc, char* argv[]) {

  std::cout << engine_info() << std::endl;
  #ifndef BENCH
    SETUP_PRIVILEGES();
  #endif
  UCI::init(Options);
  TT.resize(Options["Hash"]);
  PSQT::init();
  Bitboards::init();
  Position::init();
  Bitbases::init();
  Search::init();
  Eval::init();
  Pawns::init();
  Threads.init();
  Tablebases::init(Options["SyzygyPath"]);

  UCI::loop(argc, argv);

  if (large_use) {
    FREE_MEM(TT.mem);  
    TT.mem = nullptr;
  }

  Threads.exit();
}

celix_status_t etcdWriter_deletePublisherEndpoint(etcd_writer_pt writer, pubsub_endpoint_pt pubEP) {
	celix_status_t status = CELIX_SUCCESS;
	char *key = NULL;

	const char *rootPath = etcdWriter_getRootPath(writer->pubsub_discovery->context);

	asprintf(&key, "%s/%s/%s/%s/%ld", rootPath, pubEP->scope, pubEP->topic, pubEP->frameworkUUID, pubEP->serviceID);

	celixThreadMutex_lock(&writer->localPubsLock);
	for (unsigned int i = 0; i < arrayList_size(writer->localPubs); i++) {
		pubsub_endpoint_pt ep = arrayList_get(writer->localPubs, i);
		if (pubsubEndpoint_equals(ep, pubEP)) {
			arrayList_remove(writer->localPubs, i);
			pubsubEndpoint_destroy(ep);
			break;
		}
	}
	celixThreadMutex_unlock(&writer->localPubsLock);

	if (etcd_del(key)) {
		printf("Failed to remove key %s from ETCD\n",key);
		status = CELIX_ILLEGAL_ARGUMENT;
	}
	FREE_MEM(key);
	return status;
}