STDMETHODIMP
CControlMgt::ProjectUpload(/*[out]*/ SAFEARRAY/*(unsigned char)*/ **ppDataUp)
{
HRESULT hr = S_OK;
UINT uLen = 0;
BYTE *pData = NULL;
HEAP_ALLOC(pData, uLen);
hr = myConnection.TransferData(FALSE, CMD_LOAD_PROJECT, &pData, &uLen);
if (hr!=S_OK)
{
if (pData)
{
HEAP_FREE(pData, uLen);
}
return hr;
}
SAFEARRAYBOUND Bound;
Bound.lLbound = 0;
Bound.cElements = uLen;
(*ppDataUp) = ::SafeArrayCreate(VT_UI1, 1, &Bound);
if (NULL == (*ppDataUp))
{
return E_FAIL;
}
long lIndex = 0;
for(lIndex = 0; lIndex<(long)uLen; lIndex++)
{
unsigned char ch = pData[lIndex];
hr = ::SafeArrayPutElement((*ppDataUp), &lIndex,
(void*)(&ch));
if (FAILED(hr))
{
if (pData)
{
HEAP_FREE(pData, uLen);
}
return hr;
}
}
if (pData)
{
HEAP_FREE(pData, uLen);
}
return hr;
}
//------------------------------------------------------------------*
HRESULT CControlMgt::DoSimpleCommand(UINT uCmd, UINT uTrials)
{
HRESULT hr = S_OK;
if(uTrials == 1)
{
UINT uLen = 0;
BYTE *pData = NULL;
HEAP_ALLOC(pData, uLen);
hr = myConnection.TransferData(FALSE, uCmd, &pData, &uLen);
if (pData)
{
HEAP_FREE(pData, uLen);
}
}
else
{
UINT uResult = (UINT)-1;
for (IEC_UINT uCount = 0; SUCCEEDED(hr) && uResult != 0 && uCount < uTrials; uCount++)
{
UINT uLen = sizeof(IEC_UINT);
BYTE *pData = NULL;
if (uCount > 0) {
SleepEx(100, TRUE);
}
HEAP_ALLOC(pData, uLen);
*(IEC_UINT*)pData = TRANSLATE_SHORT(uCount);
hr = myConnection.TransferData(FALSE, uCmd, &pData, &uLen);
if (SUCCEEDED(hr) && uLen < sizeof(IEC_UINT)) {
hr = E_FAIL;
}
if (SUCCEEDED(hr)) {
uResult = TRANSLATE_SHORT(*(IEC_UINT *)pData);
}
HEAP_FREE(pData, uLen);
}
if (uCount == uTrials)
{
hr = E_FAIL;
}
}
return hr;
}
void ADBG_Case_Delete(
ADBG_Case_t *Case_p
)
{
ADBG_SubCase_Delete(Case_p->FirstSubCase_p);
HEAP_FREE(&Case_p);
}
STDMETHODIMP
CControlMgt::ProjectDownload(/*[in]*/ SAFEARRAY/*(unsigned char)*/ **ppDataDown)
{
HRESULT hr;
unsigned char HUGEP *parr;
// Get a pointer to the elements of the array.
hr = ::SafeArrayAccessData(*ppDataDown, (void HUGEP**)&parr);
if(FAILED(hr))
{
return hr;
}
UINT uLen = ((*ppDataDown)->rgsabound[0]).cElements;
BYTE *pData = NULL;
HEAP_ALLOC(pData, uLen);
memcpy(pData, parr, uLen);
::SafeArrayUnaccessData(*ppDataDown);
hr = myConnection.TransferData(FALSE, CMD_SAVE_PROJECT, &pData, &uLen);
if (pData)
{
HEAP_FREE(pData, uLen);
}
return hr;
}
static void GetDNSPrefixes(StringTimeNode **head)
{
DWORD dwRetVal = 0;
ULONG flags = GAA_FLAG_INCLUDE_PREFIX;
ULONG family = AF_UNSPEC;
PIP_ADAPTER_ADDRESSES pAddresses = NULL;
ULONG outBufLen = 0;
PIP_ADAPTER_ADDRESSES pCurrAddresses = NULL;
outBufLen = sizeof(IP_ADAPTER_ADDRESSES);
pAddresses = (IP_ADAPTER_ADDRESSES *)HEAP_ALLOC(outBufLen);
if (pAddresses == NULL)
return;
// Make an initial call to GetAdaptersAddresses to get the
// size needed into the outBufLen variable
ULONG ret = GetAdaptersAddresses(family, flags, NULL, pAddresses, &outBufLen);
if (ERROR_BUFFER_OVERFLOW == ret) {
HEAP_FREE(pAddresses);
pAddresses = (IP_ADAPTER_ADDRESSES *) HEAP_ALLOC(outBufLen);
}
if (pAddresses == NULL)
return;
dwRetVal = GetAdaptersAddresses(family, flags, NULL, pAddresses, &outBufLen);
if (dwRetVal == NO_ERROR) {
pCurrAddresses = pAddresses;
while (pCurrAddresses) {
WCHAR *dnsSuffix = pCurrAddresses->DnsSuffix;
if (dnsSuffix && *dnsSuffix) {
char *dnsSuffix2 = WstrToUtf8(dnsSuffix);
StringTimeNodeAllocAndInsert(head, dnsSuffix2);
free(dnsSuffix2);
}
pCurrAddresses = pCurrAddresses->Next;
}
}
HEAP_FREE(pAddresses);
return;
}
/* Free the memory used by a button */
void labelFree(W_LABEL *psWidget)
{
#if W_USE_STRHEAP
if (psWidget->pTip)
{
widgFreeString(psWidget->pTip);
}
#endif
ASSERT((PTRVALID(psWidget, sizeof(W_LABEL)),
"labelFree: Invalid label pointer"));
#if W_USE_MALLOC
FREE(psWidget);
#else
HEAP_FREE(psLabHeap, psWidget);
#endif
}
/* Free the memory used by a barGraph */
void barGraphFree(W_BARGRAPH *psWidget)
{
ASSERT((PTRVALID(psWidget, sizeof(W_BARGRAPH)),
"barGraphFree: Invalid widget pointer"));
#if W_USE_STRHEAP
if (psWidget->pTip)
{
widgFreeString(psWidget->pTip);
}
#endif
#if W_USE_MALLOC
FREE(psWidget);
#else
HEAP_FREE(psBarHeap, psWidget);
#endif
}
/* Free the memory used by a button */
void buttonFree(W_BUTTON *psWidget)
{
ASSERT((PTRVALID(psWidget, sizeof(W_BUTTON)),
"buttonFree: invalid button pointer"));
#if W_USE_STRHEAP
if (psWidget->pText)
{
widgFreeString(psWidget->pText);
}
if (psWidget->pTip)
{
widgFreeString(psWidget->pTip);
}
#endif
#if W_USE_MALLOC
FREE(psWidget);
#else
HEAP_FREE(psButHeap, psWidget);
#endif
}
STDMETHODIMP
CControlMgt::SaveFile(/*[in, string]*/ BSTR sName, /*[in]*/ SAFEARRAY/*(unsigned char)*/ **ppData)
{
HRESULT hr;
unsigned char HUGEP *parr;
CString strName = sName;
// Get a pointer to the elements of the array.
hr = ::SafeArrayAccessData(*ppData, (void HUGEP**)&parr);
if(FAILED(hr))
{
return hr;
}
UINT uLenData = ((*ppData)->rgsabound[0]).cElements;
UINT uLenString = strName.GetLength() + 1;
UINT uLen = uLenData + uLenString;
BYTE *pData = NULL;
HEAP_ALLOC(pData, uLen);
strcpy((char*)pData, strName);
pData[uLenString-1] = 0;
memcpy(&(pData[uLenString]), parr, uLenData);
::SafeArrayUnaccessData(*ppData);
hr = myConnection.TransferData(FALSE, CMD_SAVE_FILE, &pData, &uLen);
if (pData)
{
HEAP_FREE(pData, uLen);
}
return hr;
}
void
arrowDrawAll( void )
{
ARROW *psArrow, *psArrowTemp;
pie_SetDepthBufferStatus(DEPTH_CMP_ALWAYS_WRT_ON);
pie_SetFogStatus(FALSE);
/* draw and clear list */
psArrow = g_psArrowList;
while ( psArrow != NULL )
{
draw3dLine( &psArrow->vecHead, &psArrow->vecBase, psArrow->iColour );
psArrowTemp = psArrow->psNext;
HEAP_FREE( g_psArrowHeap, psArrow );
psArrow = psArrowTemp;
}
/* reset list */
g_psArrowList = NULL;
pie_SetDepthBufferStatus(DEPTH_CMP_LEQ_WRT_ON);
}
/* Receive
* ----------------------------------------------------------------------------
*/
ECommError CLogBlock::Receive (BYTE *bypCommand, BYTE **ppData, UINT *upLen)
{
HEAP_FREE(*ppData, *upLen);
// Build block frame
if (m_pDataFrame == NULL)
{
m_pDataFrame = (XFrame *)new char [HD_FRAME + m_Para.uBlockLen];
}
memset (m_pDataFrame, 0x00, HD_FRAME);
*upLen = 0;
USHORT uBlock = 0;
UINT uBlockLen = 0;
UINT uDataLen = 0;
BOOL bLast = FALSE;
ECommError eError;
UINT uProgMax = m_uMaxRecvProg;
UINT uProgCur = 0;
while (! bLast)
{
PROGRESS(uProgCur,uProgMax);
// Block count starts with 1!
uBlock++;
eError = ceError;
for (UINT i = 0; (i < m_uRepeatOnError && eError != ceOK) || i == 0; i++)
{
bLast = FALSE;
// Send request for response block
eError = SendInfoBlock (uBlock, BT_REQ);
if (eError != ceOK)
{
// Communication error sending block
SleepEx (m_uWaitResend, FALSE);
m_pPhys->Flush();
continue;
}
uBlockLen = m_Para.uBlockLen + HD_FRAME;
// Receive block
eError = m_pPhys->Receive((BYTE *)m_pDataFrame, &uBlockLen);
if (eError != ceOK)
{
// Communication error or time out; try again
SleepEx (m_uWaitResend, FALSE);
m_pPhys->Flush();
continue;
}
// Check block size
if (uBlockLen < HD_FRAME)
{
// Received block could not be a valid block; try again
SleepEx (m_uWaitResend, FALSE);
m_pPhys->Flush();
TrcPrint(TRC_ERROR, _T("[CLogBlock][Receive] Invalid block length.\n"));
eError = ceError;
continue;
}
// Convert Big -> Little Endian
TtoH(m_pDataFrame);
if (HD_FRAME + m_pDataFrame->BLK.uLen != uBlockLen)
{
TrcPrint(TRC_ERROR, _T("[CLogBlock][Receive] CRC frame data length check failed.\n"));
PROGRESS_LAST(uProgMax);
return ceCRC;
}
// Check CRC
if (CheckCRC (m_pDataFrame) != ceOK)
{
TRACE (_T("CRC_CRC_CRC_CRC_CRC_CRC_CRC_CRC_CRC_CRC_CRC_CRC_CRC_CRC_CRC_\n"));
TrcPrint(TRC_ERROR, _T("[CLogBlock][Receive] CRC check failed.\n"));
// Wrong checksum; send NACK and try again
SleepEx (m_uWaitResend, FALSE);
m_pPhys->Flush();
eError = ceCRC;
continue;
}
// Check block type
if (m_pDataFrame->byType != BT_DATA)
{
// Received block could not be a valid block; try again
SleepEx (m_uWaitResend, FALSE);
m_pPhys->Flush();
TrcPrint(TRC_ERROR, _T("[CLogBlock][Receive] Invalid block type (data expected).\n"));
eError = ceError;
continue;
}
bLast = m_pDataFrame->BLK.byLast;
// Check block number
if (m_pDataFrame->BLK.uBlock != uBlock)
{
// Received block number does not match
SleepEx (m_uWaitResend, FALSE);
m_pPhys->Flush();
TrcPrint(TRC_ERROR, _T("[CLogBlock][Receive] Invalid block number.\n"));
eError = ceError;
continue;
}
*bypCommand = m_pDataFrame->BLK.CMD.byCommand;
uDataLen = m_pDataFrame->BLK.uLen;
// Create Command Buffer
if (uBlock == 1)
{
HEAP_ALLOC(*ppData, uDataLen);
}
else
{
HEAP_RE_ALLOC(*ppData, *upLen + uDataLen);
}
if (*ppData == NULL)
{
TrcPrint(TRC_ERROR, _T("[CLogBlock][Receive] Alloc Memory.\n"));
eError = ceError;
continue;
}
// Copy data
memcpy(*ppData + *upLen, m_pDataFrame->BLK.CMD.pData, uDataLen);
*upLen += uDataLen;
if (m_pDataFrame->BLK.CMD.byCommand > 0x80u)
{
// Error Message from VMM
TRACE(_T("<<< %-8s %3d %4d \n"), _T("FAILED"), uBlock, m_pDataFrame->BLK.uLen);
TrcPrint(TRC_INTERFACE, _T("<<< %-8s %3d %4d \n"), _T("FAILED"), uBlock, m_pDataFrame->BLK.uLen);
PROGRESS_LAST(uProgMax);
return ceOK;
}
else
{
TRACE(_T("<<< %-8s %3d %3d \n"), m_pDataFrame->BLK.CMD.byCommand <= LAST_CMD_VALUE ? szCommandText[m_pDataFrame->BLK.CMD.byCommand] : _T("Invalid"), uBlock, m_pDataFrame->BLK.uLen);
TrcPrint(TRC_INTERFACE, _T("<<< %-8s %3d %4d \n"), m_pDataFrame->BLK.CMD.byCommand <= LAST_CMD_VALUE ? szCommandText[m_pDataFrame->BLK.CMD.byCommand] : _T("Invalid"), uBlock, m_pDataFrame->BLK.uLen);
}
} // end for
if (eError != ceOK)
{
HEAP_FREE(*ppData, *upLen);
PROGRESS_LAST(uProgMax);
return eError;
}
if (++uProgCur == uProgMax)
{
uProgMax += uProgMax;
}
} // end while
PROGRESS_LAST(uProgMax);
return ceOK;
}
void
reset_memory (void)
{
HEAP_FREE (memory_block_start);
DEALLOCATE_REGISTERS ();
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int CProcessor::StopoutsApply(const UserInfo *user, const ConGroup *group,
const char *comment)
{
Out(CmdOK, "CProcessor::StopoutsApply - Applying stopout for user [%d]", user->login);
TradeRecord *trades,*trade;
int total, i;
ConSymbol symbol = {0};
TradeTransInfo trans = {0};
time_t currtime;
char stopout[64] = "[stopout]";
const char *cp;
// check
if (user == NULL || group == NULL || comment == NULL)
{
Out(CmdOK, "CProcessor::StopoutsApply - check failed");
return RET_OK;
}
// lock
m_sync.Lock();
// check user group
if (CheckGroup(m_groups, group->group) == FALSE)
{
Out(CmdOK, "CProcessor::StopoutsApply - group check failed");
m_sync.Unlock();
return(RET_OK);
}
// receive all opened trades for user
if ((trades = ExtServer->OrdersGetOpen(user, &total)) == NULL)
{
Out(CmdOK, "CProcessor::StopoutsApply - no open trade");
return RET_OK;
}
// get current server time
currtime = ExtServer->TradeTime();
// prepare comment about stopout
if ((cp = strrchr(comment, '[')) != NULL) COPY_STR(stopout, cp);
// output to server log
Out(CmdOK, "'%d': close all orders due stop out %s", user->login, stopout);
// go trough trades
for (i = 0, trade = trades; i < total; i++, trade++)
{
// it is opened trade
if (trade->cmd > OP_SELL) continue;
// check symbol - зачем?
// if (CheckGroup(m_symbols, trade->symbol) == FALSE) continue;
// check volume - зачем?
// if (m_max_volume != 0 && trade->volume > m_max_volume) continue;
// receive symbol information
if (ExtServer->SymbolsGet(trade->symbol, &symbol) == FALSE)
{
Out(CmdAtt, "stopout: receiving information for %s symbol failed", trade->symbol);
continue;
}
// check trade session for symbol
if (ExtServer->TradesCheckSessions(&symbol, currtime) == FALSE) continue;
// prepare transaction
trans.order = trade->order;
trans.price = trade->close_price;
trans.volume = trade->volume;
trans.type = TT_ORDER_MK_CLOSE; // !
// prepare comment
if (trade->comment[0] != 0)
{
COPY_STR(trans.comment, trade->comment);
if (strstr(trans.comment, stopout) == NULL)
_snprintf(trans.comment, sizeof(trans.comment) - 1, "%s %s", trans.comment, "[stopout FXI]");
}
else
COPY_STR(trans.comment, stopout);
// отправить запрос на закрытие позиции на сервер
// создать запрос
RequestInfo inf = { 0 };
memcpy(&(inf.trade), &trans, sizeof(TradeTransInfo));
inf.login = user->login;
inf.id = trade->order; // startStopoutRequestId++; // !!
memcpy(&inf.group, &group->group, sizeof(inf.group));
memcpy(&inf.trade.symbol, &trade->symbol, sizeof(trade->symbol));
// добавить в очередь
Add(&inf, TRUE);
}
m_sync.Unlock();
// free memory
HEAP_FREE(trades);
// сервер больше не процессит стопаут
return RET_OK_NONE;
}
// IpType : 0 : IPV6 and IPV4; 4:IPV4; 6:IPV6
U32 CDeviceMgr_i::GetAdapterInfo(NET_ADAPTER_INFO AdapterList[10],U8& AdapterListCnt, U8 IpType)
{
U32 ret = ERR_OK_I;
//DWORD dwSize = 0;
//DWORD dwRetVal = 0;
int i = 0;
// Set the flags to pass to GetAdaptersAddresses
ULONG flags = GAA_FLAG_INCLUDE_PREFIX;
// default to unspecified address family (both)
ULONG family = AF_UNSPEC;
//LPVOID lpMsgBuf = NULL;
PIP_ADAPTER_ADDRESSES pAddresses = NULL;
//ULONG outBufLen = 0;
PIP_ADAPTER_ADDRESSES pCurrAddresses = NULL;
PIP_ADAPTER_UNICAST_ADDRESS pUnicast = NULL;
PIP_ADAPTER_ANYCAST_ADDRESS pAnycast = NULL;
PIP_ADAPTER_MULTICAST_ADDRESS pMulticast = NULL;
IP_ADAPTER_DNS_SERVER_ADDRESS *pDnServer = NULL;
IP_ADAPTER_PREFIX *pPrefix = NULL;
if (IpType == 4)
family = AF_INET;
else if (IpType == 6)
family = AF_INET6;
else
family = AF_UNSPEC;
ULONG uListSize = sizeof(g_buffer); // max. 10 adpater
//int nAdapterIndex = 0;
bool bDeleteBuffer = FALSE;
pAddresses = (PIP_ADAPTER_ADDRESSES)g_buffer;
AdapterListCnt = 0;
DWORD dwRet = GetAdaptersAddresses(family, flags, NULL, pAddresses, &uListSize);
if (dwRet == ERROR_NO_DATA) // No adapter information exists for the local computer.
{
TRACE_I(_T("** No adapter information exists for the local computer!\n"));
ret = ERR_NO_ADAPTER_I;
}
else if (dwRet == ERROR_BUFFER_OVERFLOW)
{
pAddresses = (PIP_ADAPTER_ADDRESSES)HEAP_ALLOC(uListSize);
bDeleteBuffer = TRUE;
dwRet = GetAdaptersAddresses(family, flags, NULL, pAddresses, &uListSize);
if(pAddresses == NULL)
return ERR_NO_MORE_MEMORY_I;
}
else if(dwRet == ERROR_INVALID_PARAMETER)
{
ret = ERR_INVALID_PARAM_I;
}
else
{
ret = ERR_WIN32_ERROR_I;
}
TCHAR buff[256];
//DWORD bufflen = 256;
if (dwRet == ERROR_SUCCESS)
{
ret = ERR_OK_I;
pCurrAddresses = pAddresses;
U8 ulIdx = 0;
while (pCurrAddresses)
{
if(ulIdx >= 10)
break;
NET_ADAPTER_INFO* pAdapterList = (NET_ADAPTER_INFO*)&AdapterList[ulIdx++];
AdapterListCnt = ulIdx;
//printf("\tLength of the IP_ADAPTER_ADDRESS struct: %ld\n", pCurrAddresses->Length);
pAdapterList->IfIndex = pCurrAddresses->IfIndex;
//printf("\tIfIndex (IPv4 interface): %u\n", pCurrAddresses->IfIndex); // Specifies the index of the interface with which these addresses are associated.
#ifdef HAVE_UNICODE_I
mbs2wcsz(buff, sizeof(buff), pCurrAddresses->AdapterName);
StrCpyN(pAdapterList->szAdapterName,buff, sizeof(pAdapterList->szAdapterName));
#else
StrCpyN(pAdapterList->szAdapterName, pCurrAddresses->AdapterName, sizeof(pAdapterList->szAdapterName));
#endif
//printf("\tAdapter name: %s\n", pCurrAddresses->AdapterName);
pAdapterList->bWirelessCard = IsWirelessCard(pAdapterList->szAdapterName);
#ifdef HAVE_UNICODE_I
StrCpyN(pAdapterList->szDnsSuffix, pCurrAddresses->DnsSuffix, sizeof(pAdapterList->szDnsSuffix));
#else
wcs2mbsz(buff, sizeof(buff), pCurrAddresses->DnsSuffix);
//printf("\tDNS Suffix: %s\n", buff);
StrCpyN(pAdapterList->szDnsSuffix, buff, sizeof(pAdapterList->szDnsSuffix));
#endif
#ifdef HAVE_UNICODE_I
StrCpyN(pAdapterList->szDescription, pCurrAddresses->Description, sizeof(pAdapterList->szDescription));
#else
wcs2mbsz(buff, sizeof(buff), pCurrAddresses->Description);
StrCpyN(pAdapterList->szDescription, buff, sizeof(pAdapterList->szDescription));
#endif
//_tprintf(_T("\tDescription: %s\n"), pAdapterList->szDescription);
#ifdef HAVE_UNICODE_I
StrCpyN(pAdapterList->szConnectionName, pCurrAddresses->FriendlyName, sizeof(pAdapterList->szConnectionName));
#else
wcs2mbsz(buff, sizeof(buff), pCurrAddresses->FriendlyName);
StrCpyN(pAdapterList->szConnectionName, buff, sizeof(pAdapterList->szConnectionName));
#endif
//printf("\tFriendly name: %s\n", buff);
pUnicast = pCurrAddresses->FirstUnicastAddress;
if (pUnicast != NULL)
{
for (i = 0; pUnicast != NULL; i++)
{
if(i>=0xFF)
break;
if(FillIpAddr(buff, pUnicast->Address, i, pAdapterList->UnicastAddr) == FALSE)
break;
//printf("\tIP Address(Unicast Addresses): %s \n", buff);
pUnicast = pUnicast->Next;
}
pAdapterList->UnicastAddrCnt = (u8)(i&0x0FF);
//printf("\tNumber of Unicast Addresses: %d\n", i);
}
else
{
pAdapterList->UnicastAddrCnt = 0;
//printf("\tNo Unicast Addresses\n");
}
pAnycast = pCurrAddresses->FirstAnycastAddress;
if (pAnycast)
{
for (i = 0; pAnycast != NULL; i++)
{
if(i>=0xFF)
break;
if(FillIpAddr(buff, pAnycast->Address, i, pAdapterList->AnycastAddr) == FALSE)
break;
//printf("\tIP Address(Anycast Addresses): %s \n", buff);
pAnycast = pAnycast->Next;
}
//printf("\tNumber of Anycast Addresses: %d\n", i);
pAdapterList->AnycastAddrCnt = (u8)(i&0x0FF);
}
else
{
pAdapterList->AnycastAddrCnt = 0;
// printf("\tNo Anycast Addresses\n");
}
pMulticast = pCurrAddresses->FirstMulticastAddress;
if (pMulticast)
{
for (i = 0; pMulticast != NULL; i++)
{
if(i>=0xFF)
break;
if(FillIpAddr(buff, pMulticast->Address, i, pAdapterList->MulticastAddr) == FALSE)
break;
//printf("\tIP Address(Multicast Addresses): %s \n", buff);
pMulticast = pMulticast->Next;
}
pAdapterList->MulticastAddrCnt = (u8)(i&0x0FF);
//printf("\tNumber of Multicast Addresses: %d\n", i);
}
else
{
//printf("\tNo Multicast Addresses\n");
pAdapterList->MulticastAddrCnt = 0;
}
pDnServer = pCurrAddresses->FirstDnsServerAddress;
if (pDnServer)
{
for (i = 0; pDnServer != NULL; i++)
{
if(i>=0xFF)
break;
if(FillIpAddr(buff, pDnServer->Address, i, pAdapterList->DnsServer) == FALSE)
break;
//printf("\tIP Address(DNS Server): %s \n", buff);
pDnServer = pDnServer->Next;
}
pAdapterList->DnsServerCnt = (u8)(i&0x0FF);
//printf("\tNumber of DNS Server Addresses: %d\n", i);
}
else
{
//printf("\tNo DNS Server Addresses\n");
pAdapterList->DnsServerCnt = 0;
}
pPrefix = pCurrAddresses->FirstPrefix;
if (pPrefix)
{
for (i = 0; pPrefix != NULL; i++)
{
if(i>=0xFF)
break;
if(FillIpAddr(buff, pPrefix->Address, i, pAdapterList->PrefixAddr) == FALSE)
break;
pPrefix = pPrefix->Next;
}
pAdapterList->PrefixAddrCnt = (u8)(i&0x0FF);
}
else
{
pAdapterList->PrefixAddrCnt = 0;
//printf("\tNo IP Adapter Prefix entries\n");
}
pAdapterList->uMacAddressLen = 0;
pAdapterList->uMacAddress[0] = 0;
if (pCurrAddresses->PhysicalAddressLength != 0)
{
pAdapterList->uMacAddressLen = (u8)(pCurrAddresses->PhysicalAddressLength);
memcpy(pAdapterList->uMacAddress, pCurrAddresses->PhysicalAddress, pAdapterList->uMacAddressLen);
FormatMACToStr(pAdapterList->szMacAddr, pCurrAddresses->PhysicalAddress, pCurrAddresses->PhysicalAddressLength);
}
/*
IP_ADAPTER_DDNS_ENABLED(0x01) Dynamic DNS is enabled on this adapter.
IP_ADAPTER_REGISTER_ADAPTER_SUFFIX (0x02) Register the DNS suffix for this adapter.
IP_ADAPTER_DHCP_ENABLED (0x04) Dynamic Host Configuration Protocol is enabled on this adapter.
*/
//printf("\tFlags: %ld\n", pCurrAddresses->Flags);
pAdapterList->Flags = pCurrAddresses->Flags;
pAdapterList->bDhcpEnabled = (pCurrAddresses->Flags&IP_ADAPTER_DHCP_ENABLED) ? TRUE:FALSE;
pAdapterList->bDDNSEnabled = (pCurrAddresses->Flags&IP_ADAPTER_DDNS_ENABLED) ? TRUE:FALSE;
pAdapterList->Mtu = pCurrAddresses->Mtu;
//printf("\tMtu: %lu Bytes\n", pCurrAddresses->Mtu); // Specifies the maximum transmission unit (MTU), in bytes.
/*
#define MIB_IF_TYPE_OTHER 1
#define MIB_IF_TYPE_ETHERNET 6
#define MIB_IF_TYPE_TOKENRING 9
#define MIB_IF_TYPE_FDDI 15
#define MIB_IF_TYPE_PPP 23
#define MIB_IF_TYPE_LOOPBACK 24
#define MIB_IF_TYPE_SLIP 28
*/
pAdapterList->IfType = pCurrAddresses->IfType;
//printf("\tIfType: %ld\n", pCurrAddresses->IfType); // Specifies the type of interface using the values defined by the Internet Assigned Numbers Authority (IANA).
if(pCurrAddresses->IfType == MIB_IF_TYPE_ETHERNET)
{
pAdapterList->bEthernetCard = TRUE;
pAdapterList->bPhysicalCard = TRUE;
}
else
{
pAdapterList->bEthernetCard = FALSE;
pAdapterList->bPhysicalCard = FALSE;
}
/*
// OperStatus values from RFC 2863
typedef enum {
IfOperStatusUp = 1,
IfOperStatusDown,
IfOperStatusTesting,
IfOperStatusUnknown,
IfOperStatusDormant,
IfOperStatusNotPresent,
IfOperStatusLowerLayerDown
} IF_OPER_STATUS; */
pAdapterList->OperStatus = pCurrAddresses->OperStatus;
if(pCurrAddresses->OperStatus==IfOperStatusUp)
{
pAdapterList->bConnected = TRUE;
}
else if(pCurrAddresses->OperStatus==IfOperStatusDown)
{
pAdapterList->bConnected = FALSE;
}
//printf("\tOperStatus: %ld\n", pCurrAddresses->OperStatus);
// Specifies the operational status of the interface
pAdapterList->Ipv6IfIndex = pCurrAddresses->Ipv6IfIndex;
//printf("\tIpv6IfIndex (IPv6 interface): %u\n", pCurrAddresses->Ipv6IfIndex);
// printf("\tZoneIndices (hex): ");
// for (i = 0; i < 16; i++)
// {
// printf("%lx ", pCurrAddresses->ZoneIndices[i]);
// }
// printf("\n");
pCurrAddresses = pCurrAddresses->Next;
} // while
}
else if (dwRet == ERROR_NO_DATA) // No adapter information exists for the local computer.
{
TRACE_I(_T("*** No adapter information exists for the local computer!\n"));
ret = ERR_NO_ADAPTER_I;
}
else if (dwRet == ERROR_BUFFER_OVERFLOW)
{
ret = ERR_NO_MORE_MEMORY_I;
}
else if(dwRet == ERROR_INVALID_PARAMETER)
{
ret = ERR_INVALID_PARAM_I;
}
else
{
ret = ERR_WIN32_ERROR_I;
}
if(bDeleteBuffer && pAddresses)
{
HEAP_FREE(pAddresses);
}
return ret;
}
STDMETHODIMP
CControlMgt::ProjectInfoUpload(/*[out, string]*/ BSTR* psProjVers,
/*[out, string]*/ BSTR* psProjName,
/*[out, string]*/ BSTR* psModified,
/*[out, string]*/ BSTR* psCreated,
/*[out, string]*/ BSTR* psOwner,
/*[out, string]*/ BSTR* psComment1,
/*[out, string]*/ BSTR* psComment2,
/*[out, string]*/ BSTR* psComment3)
{
HRESULT hr = S_OK;
CString strProjVers;
CString strProjName;
CString strModified;
CString strCreated;
CString strOwner;
CString strComment1;
CString strComment2;
CString strComment3;
if (psProjVers == NULL ||
psProjName == NULL ||
psModified == NULL ||
psCreated == NULL ||
psOwner == NULL ||
psComment1 == NULL ||
psComment2 == NULL ||
psComment3 == NULL)
{
return E_POINTER;
}
*psProjVers = NULL;
*psProjName = NULL;
*psModified = NULL;
*psCreated = NULL;
*psOwner = NULL;
*psComment1 = NULL;
*psComment2 = NULL;
*psComment3 = NULL;
UINT uLen = 0;
BYTE *pData = NULL;
HEAP_ALLOC(pData, uLen);
hr = myConnection.TransferData(FALSE, CMD_GET_PROJ_INFO, &pData, &uLen);
if (uLen < sizeof(XProjInfo))
{
hr = E_FAIL;
}
if (SUCCEEDED(hr))
{
try
{
XProjInfo* pPI = (XProjInfo*)pData;
strProjVers = pPI->szProjVers;
strProjName = pPI->szProjName;
strModified = pPI->szModified;
strCreated = pPI->szCreated;
strOwner = pPI->szOwner;
strComment1 = pPI->szComment1;
strComment2 = pPI->szComment2;
strComment3 = pPI->szComment3;
*psProjVers = strProjVers.AllocSysString();
*psProjName = strProjName.AllocSysString();
*psModified = strModified.AllocSysString();
*psCreated = strCreated.AllocSysString();
*psOwner = strOwner.AllocSysString();
*psComment1 = strComment1.AllocSysString();
*psComment2 = strComment2.AllocSysString();
*psComment3 = strComment3.AllocSysString();
}
catch (CMemoryException* e)
{
e->Delete();
if (*psProjVers)
{
SysFreeString(*psProjVers);
}
if (*psProjName)
{
SysFreeString(*psProjName);
}
if (*psModified)
{
SysFreeString(*psModified);
}
if (*psCreated)
{
SysFreeString(*psCreated);
}
if (*psOwner)
{
SysFreeString(*psOwner);
}
if (*psComment1)
{
SysFreeString(*psComment1);
}
if (*psComment2)
{
SysFreeString(*psComment2);
}
if (*psComment3)
{
SysFreeString(*psComment3);
}
hr = E_OUTOFMEMORY;
}
}
HEAP_FREE(pData, uLen);
return hr;
}
//=======================================================================
// interface ICustOnlCmds
//=======================================================================
//------------------------------------------------------------------*
STDMETHODIMP
CControlMgt::CustDownUpLoad(/*[in]*/ SAFEARRAY/*(unsigned char)*/ **ppDataDown,
/*[out]*/ SAFEARRAY/*(unsigned char)*/ **ppDataUp)
{
HRESULT hr;
unsigned char HUGEP *parr;
// Get a pointer to the elements of the array.
hr = ::SafeArrayAccessData(*ppDataDown, (void HUGEP**)&parr);
if(FAILED(hr))
{
return hr;
}
UINT uLen = ((*ppDataDown)->rgsabound[0]).cElements;
BYTE *pData = NULL;
HEAP_ALLOC(pData, uLen);
memcpy(pData, parr, uLen);
::SafeArrayUnaccessData(*ppDataDown);
hr = myConnection.TransferData(FALSE, CMD_CUSTOM, &pData, &uLen);
if (hr!=S_OK)
{
if (pData)
{
HEAP_FREE(pData, uLen);
}
return hr;
}
SAFEARRAYBOUND Bound;
Bound.lLbound = 0;
Bound.cElements = uLen;
(*ppDataUp) = ::SafeArrayCreate(VT_UI1, 1, &Bound);
if (NULL == (*ppDataUp))
{
return E_FAIL;
}
long lIndex = 0;
for(lIndex = 0; lIndex<(long)uLen; lIndex++)
{
unsigned char ch = pData[lIndex];
hr = ::SafeArrayPutElement((*ppDataUp), &lIndex,
(void*)(&ch));
if (FAILED(hr))
{
if (pData)
{
HEAP_FREE(pData, uLen);
}
return hr;
}
}
if (pData)
{
HEAP_FREE(pData, uLen);
}
return hr;
}
STDMETHODIMP
CControlMgt::LoadFile(/*[in, string]*/ BSTR sName, /*[out]*/ SAFEARRAY/*(unsigned char)*/ **ppData)
{
HRESULT hr;
CString strName = sName;
UINT uLen= strName.GetLength() + 1;
BYTE *pData = NULL;
HEAP_ALLOC(pData, uLen);
strcpy((char*)pData, strName);
pData[uLen-1] = 0;
hr = myConnection.TransferData(FALSE, CMD_LOAD_FILE, &pData, &uLen);
if (hr!=S_OK)
{
if (pData)
{
HEAP_FREE(pData, uLen);
}
return hr;
}
SAFEARRAYBOUND Bound;
Bound.lLbound = 0;
Bound.cElements = uLen;
(*ppData) = ::SafeArrayCreate(VT_UI1, 1, &Bound);
if (NULL == (*ppData))
{
return E_FAIL;
}
long lIndex = 0;
for(lIndex = 0; lIndex<(long)uLen; lIndex++)
{
unsigned char ch = pData[lIndex];
hr = ::SafeArrayPutElement((*ppData), &lIndex,
(void*)(&ch));
if (FAILED(hr))
{
if (pData)
{
HEAP_FREE(pData, uLen);
}
return hr;
}
}
if (pData)
{
HEAP_FREE(pData, uLen);
}
return hr;
}
/* Create a button widget data structure */
BOOL buttonCreate(W_BUTTON **ppsWidget, W_BUTINIT *psInit)
{
if (psInit->style & ~(WBUT_PLAIN | WIDG_HIDDEN | WFORM_NOCLICKMOVE |
WBUT_NOPRIMARY | WBUT_SECONDARY | WBUT_TXTCENTRE ))
{
ASSERT((FALSE, "Unknown button style"));
return FALSE;
}
//#ifdef DEBUG
// if (psInit->pText)
// {
// ASSERT((PTRVALID(psInit->psFont, sizeof(PROP_FONT)),
// "buttonCreate: Invalid font pointer"));
// }
//#endif
/* Allocate the required memory */
#if W_USE_MALLOC
*ppsWidget = (W_BUTTON *)MALLOC(sizeof(W_BUTTON));
if (*ppsWidget == NULL)
#else
if (!HEAP_ALLOC(psButHeap, ppsWidget))
#endif
{
ASSERT((FALSE, "buttonCreate: Out of memory"));
return FALSE;
}
/* Allocate memory for the text and copy it if necessary */
if (psInit->pText)
{
#if W_USE_STRHEAP
if (!widgAllocCopyString(&(*ppsWidget)->pText, psInit->pText))
{
ASSERT((FALSE, "buttonCreate: Out of memory"));
#if W_USE_MALLOC
FREE(*ppsWidget);
#else
HEAP_FREE(psButHeap, *ppsWidget);
#endif
return FALSE;
}
#else
(*ppsWidget)->pText = psInit->pText;
#endif
}
else
{
(*ppsWidget)->pText = NULL;
}
/* Allocate the memory for the tip and copy it if necessary */
if (psInit->pTip)
{
#if W_USE_STRHEAP
if (!widgAllocCopyString(&(*ppsWidget)->pTip, psInit->pTip))
{
/* Out of memory - just carry on without the tip */
ASSERT((FALSE, "buttonCreate: Out of memory"));
(*ppsWidget)->pTip = NULL;
}
#else
(*ppsWidget)->pTip = psInit->pTip;
#endif
}
else
{
(*ppsWidget)->pTip = NULL;
}
/* Initialise the structure */
(*ppsWidget)->type = WIDG_BUTTON;
(*ppsWidget)->id = psInit->id;
(*ppsWidget)->formID = psInit->formID;
(*ppsWidget)->style = psInit->style;
(*ppsWidget)->x = psInit->x;
(*ppsWidget)->y = psInit->y;
(*ppsWidget)->width = psInit->width;
(*ppsWidget)->height = psInit->height;
(*ppsWidget)->callback = psInit->pCallback;
(*ppsWidget)->pUserData = psInit->pUserData;
(*ppsWidget)->UserData = psInit->UserData;
(*ppsWidget)->AudioCallback = WidgGetAudioCallback();
(*ppsWidget)->HilightAudioID = WidgGetHilightAudioID();
(*ppsWidget)->ClickedAudioID = WidgGetClickedAudioID();
if (psInit->pDisplay)
{
(*ppsWidget)->display = psInit->pDisplay;
}
else
{
(*ppsWidget)->display = buttonDisplay;
}
// (*ppsWidget)->psFont = psInit->psFont;
(*ppsWidget)->FontID = psInit->FontID;
buttonInitialise(*ppsWidget);
return TRUE;
}
// remove a droid from a group
void grpLeave(DROID_GROUP *psGroup, DROID *psDroid)
{
DROID *psPrev, *psCurr;
ASSERT((PTRVALID(psGroup, sizeof(DROID_GROUP)),
"grpLeave: invalid group pointer"));
if ( (psDroid != NULL )
&& (psDroid->psGroup != psGroup) )
{
ASSERT((FALSE, "grpLeave: droid group does not match"));
return;
}
psGroup->refCount -= 1;
// if psDroid == NULL just decrease the refcount don't remove anything from the list
if (psDroid != NULL &&
(psDroid->droidType != DROID_COMMAND ||
psGroup->type != GT_COMMAND))
{
psPrev = NULL;
for(psCurr = psGroup->psList; psCurr; psCurr = psCurr->psGrpNext)
{
if (psCurr == psDroid)
{
break;
}
psPrev = psCurr;
}
ASSERT((psCurr != NULL, "grpLeave: droid not found"));
if (psCurr != NULL)
{
if (psPrev)
{
psPrev->psGrpNext = psCurr->psGrpNext;
}
else
{
psGroup->psList = psGroup->psList->psGrpNext;
}
}
}
if (psDroid)
{
psDroid->psGroup = NULL;
psDroid->psGrpNext = NULL;
if ((psDroid->droidType == DROID_COMMAND) &&
(psGroup->type == GT_COMMAND))
{
psGroup->type = GT_NORMAL;
psGroup->psCommander = NULL;
}
else if ((psDroid->droidType == DROID_TRANSPORTER) &&
(psGroup->type == GT_TRANSPORTER))
{
psGroup->type = GT_NORMAL;
}
}
// free the group structure if necessary
if (psGroup->refCount <= 0)
{
HEAP_FREE(psGrpHeap, psGroup);
}
}
