int SctpSocket::AddAddress(const std::string& a,port_t p)
{
#ifdef ENABLE_IPV6
#ifdef IPPROTO_IPV6
if (IsIpv6())
{
Ipv6Address ad(a, p);
return AddAddress(ad);
}
#endif
#endif
Ipv4Address ad(a, p);
return AddAddress(ad);
}
void ChangeElement_test()
{
pListHeader headerA;
InitListHeader(&headerA, 'A');
int StartIndex = 0;
int EndIndex = 100;
for(int i = StartIndex; i < EndIndex; i++)
{
pElementType tmp;
tmp = malloc(sizeof(ElementType));
if(tmp == NULL)
{
printf("malloc failed in Practice_3_2!\n");
break;
}
tmp->data = i;
AddAddress(tmp, headerA);
tmp->data = i * i;
ChangeElement(i, tmp, headerA);
}
PrintList(headerA);
FreeList(headerA);
}
bool TcpAddressList::HasAddressOrAdd(struct in_addr ip, unsigned short port)
{
if(HasAddress(ip, port) == false)
{
AddAddress(ip, port);
return false;
}
return true;
}
void InitData()
{
pListHeader headerA;
pListHeader headerB;
InitListHeader(&headerA, 'A');
InitListHeader(&headerB, 'B');
for(int i = 10; i < 50; i++)
{
pElementType tmp;
tmp = malloc(sizeof(ElementType));
if(tmp == NULL)
{
printf("malloc failed in Practice_3_2!\n");
break;
}
tmp->data = i;
AddAddress(tmp, headerA);
}
for(int i = 10; i < 20; i++)
{
pElementType tmp;
tmp = malloc(sizeof(ElementType));
if(tmp == NULL)
{
printf("malloc failed in Practice_3_2!\n");
break;
}
tmp->data = i;
AddAddress(tmp, headerB);
}
PrintCrossList(headerA, headerB);
FreeList(headerA);
FreeList(headerB);
}
//------------------------------------------------------------------------------------------------------------------------------------------------------
int SUB_pIY_D(void)
{
#ifdef LISTING
AddOpcode(RAM8(PC));
AddAddress(PC + 1);
sprintf(MNEMONIC, "SUB (IY+0x%02x)", PCandInc());
return -1;
#else
return 0;
#endif
}
//------------------------------------------------------------------------------------------------------------------------------------------------------
int XOR_pIY_D(void)
{
#ifdef LISTING
AddOpcode(RAM8(PC + 1));
AddAddress(PC + 1);
sprintf(MNEMONIC, "XOR [IY+%02X]", PCandInc());
return -1;
#else
return 0;
#endif
}
//------------------------------------------------------------------------------------------------------------------------------------------------------
int DEC_pIY_D(void)
{
#ifdef LISTING
AddOpcode(RAM8(PC));
sprintf(MNEMONIC, "DEC (IY+%d)", PCandInc());
AddAddress(PC);
return -1;
#else
return 0;
#endif
}
//------------------------------------------------------------------------------------------------------------------------------------------------------
int ADD_A_pIY_D(void)
{
#ifdef LISTING
AddOpcode(RAM8(PC));
AddAddress(PC + 1);
sprintf(MNEMONIC, "ADD A,[IY+%02X]", prevPC);
return -1;
#else
return 0;
#endif
}
//------------------------------------------------------------------------------------------------------------------------------------------------------
int LD_R_pIY_D(void)
{
#ifdef LISTING
uint8 valReg = prevPC;
AddOpcode(RAM8(PC));
AddAddress(PC + 1);
sprintf(MNEMONIC, "LD %s,[IY+%02X]", R8_HI_Name(valReg), PCandInc());
return -1;
#else
return 0;
#endif
}
void BanList::Deserialize(tinyxml2::XMLElement* root)
{
tinyxml2::XMLElement* entries = nullptr;
tinyxml2::XMLElement* entry = nullptr;
entries = root->FirstChildElement("entries");
if (!entries)
{
return;
}
for (entry = entries->FirstChildElement(); entry; entry = entries->NextSiblingElement())
{
AddAddress(entry->Attribute("address"));
}
}
otError SourceMatchController::AddPendingEntries(void)
{
otError error = OT_ERROR_NONE;
for (ChildTable::Iterator iter(GetInstance(), ChildTable::kInStateValidOrRestoring); !iter.IsDone(); iter++)
{
if (iter.GetChild()->IsIndirectSourceMatchPending())
{
SuccessOrExit(error = AddAddress(*iter.GetChild()));
iter.GetChild()->SetIndirectSourceMatchPending(false);
}
}
exit:
return error;
}
void SourceMatchController::AddEntry(Child &aChild)
{
aChild.SetIndirectSourceMatchPending(true);
if (!IsEnabled())
{
SuccessOrExit(AddPendingEntries());
Enable(true);
}
else
{
VerifyOrExit(AddAddress(aChild) == OT_ERROR_NONE, Enable(false));
aChild.SetIndirectSourceMatchPending(false);
}
exit:
return;
}
//------------------------------------------------------------------------------------------------------------------------------------------------------
int LD_pIY_D_R(void)
{
#ifdef LISTING
AddOpcode(RAM8(PC));
char *reg = R8_LO_Name(prevPC);
sprintf(MNEMONIC, "LD (IY+%d), %s", PCandInc(), reg);
AddAddress(PC);
return -1;
#else
return 0;
#endif
}
//------------------------------------------------------------------------------------------------------------------------------------------------------
int LD_pIY_D_N(void)
{
#ifdef LISTING
AddOpcode(RAM8(PC));
AddOpcode(RAM8(PC + 1));
AddAddress(PC + 2);
uint8 valD = PCandInc();
uint8 valN = PCandInc();
sprintf(MNEMONIC, "LD [IY+%02X],%02X", valD, valN);
return -1;
#else
return 0;
#endif
}
//------------------------------------------------------------------------------------------------------------------------------------------------------
int LD_IY_NN(void)
{
#ifdef LISTING
AddOpcode(RAM8(PC));
AddOpcode(RAM8(PC + 1));
uint16 NN = PC16andInc();
AddAddress(PC);
sprintf(MNEMONIC, "LD IY,%04x", NN);
return -1;
#else
return 0;
#endif
}
void AddAddress_test()
{
pListHeader headerA;
InitListHeader(&headerA, 'A');
int StartIndex = 0;
int EndIndex = 10000;
int Length = EndIndex - StartIndex;
pElementType pArr[Length];
int k = 0;
for(int i = StartIndex; i < EndIndex; i++, k++)
{
pElementType tmp;
tmp = malloc(sizeof(ElementType));
if(tmp == NULL)
{
printf("malloc failed in Practice_3_2!\n");
break;
}
tmp->data = i;
pArr[k] = tmp;
AddAddress(tmp, headerA);
}
{
for(int i = 0; i < Length; i++)
{
//printf("%p\t%p\n", pArr[i], headerA->pltArr[i]);
if(pArr[i] != headerA->pltArr[i])
printf("WRONG:\n\t%d %p\t%p\n", i, pArr[i], headerA->pltArr[i]);
}
}
FreeList(headerA);
}
static int ReadTmCfg(char *pchFileName,
char *pchNameBuffer, char *pchOutbound,
char *pchNetmail, USERDATAOPT *pUserData, PDESCLIST *ppDescList)
{
FILE *pfTmCfg;
char zeile[200];
pfTmCfg=fopen(pchFileName, "r");
if (pfTmCfg)
{
while (!feof(pfTmCfg))
{
if (fgets(zeile, sizeof(zeile), pfTmCfg))
{
/* Whitespace u. Kommentare entfernen */
StripWhitespace(zeile);
if (zeile[0]) /* Zeile m. Inhalt */
{
char *pchKeyword;
char *pchParam, *pchParam2;
char *pchDup = strdup(zeile);
pchKeyword = strtok(zeile, " \t");
if (pchKeyword)
{
pchParam = strtok(NULL, " \t");
switch(QueryKeyword(pchKeyword))
{
case KEY_NETMAIL:
if (!pchNetmail[0] && pchParam)
{
strcpy(pchNetmail, pchParam);
RemoveBackslash(pchOutbound);
}
break;
case KEY_OUTBOUND:
if (!pchOutbound[0] && pchParam)
{
strcpy(pchOutbound, pchParam);
RemoveBackslash(pchOutbound);
}
break;
case KEY_AREAFILE:
if (!pchNameBuffer[0] && pchParam)
strcpy(pchNameBuffer, pchParam);
break;
case KEY_ORIGIN:
if (pchParam)
AddOrigin(pUserData, pchDup);
break;
case KEY_NAME:
if (pchParam)
AddName(pUserData, pchDup);
break;
case KEY_ADDRESS:
if (pchParam)
AddAddress(pUserData, pchParam);
break;
case KEY_ADESC:
if (ppDescList)
{
pchParam2 = strtok(NULL, " \t");
if (pchParam2)
{
PDESCLIST pNewDesc;
pNewDesc = calloc(1, sizeof(DESCLIST));
if (pNewDesc)
{
char *pchTemp;
/* vorne einhaengen */
pNewDesc->next = *ppDescList;
*ppDescList = pNewDesc;
/* Daten */
strncpy(pNewDesc->pchAreaTag, pchParam, LEN_AREATAG);
strncpy(pNewDesc->pchDesc, pchParam2, LEN_AREADESC);
/* _ umwandeln */
pchTemp = pNewDesc->pchDesc;
while (*pchTemp)
{
if (*pchTemp == '_')
*pchTemp = ' ';
pchTemp++;
}
}
}
}
break;
default:
/* unbekannt/unbehandelt */
break;
}
}
free(pchDup);
}
}
else
if (ferror(pfTmCfg))
{
/* Fehler beim Lesen der Datei */
fclose(pfTmCfg);
return CFGFILE_READ;
}
}
fclose(pfTmCfg);
return CFGFILE_OK;
}
else
return CFGFILE_OPEN;
}
void CTM2Hack::DefineAddresses(void)
{
const DWORD TMMODULESTART = 0x00401000;
const DWORD TMMODULESIZE = 0x00e61000;
m_vecAddresses.clear();
AddAddress("BaseP1", TMMODULESTART, TMMODULESIZE, (BYTE*)"\xA1\x00\x00\x00\x00\x83\x7C\x01\x48\x00\x74\x46\xF3\x0F\x10\x87", "x????xxx?xx?xxxx", 0x1, true);
AddAddress("MeterHack", TMMODULESTART, TMMODULESIZE, (BYTE*)"\x89\x83\x00\x00\x00\x00\x85\xED\x74\x39", "xx????xxxx");
AddAddress("NoPlatCount", TMMODULESTART, TMMODULESIZE, (BYTE*)"\x40\x3B\xC1\x0F\x43\xC1", "xxxxxx");
AddAddress("NoGrasDirt", TMMODULESTART, TMMODULESIZE, (BYTE*)"\x66\x8B\x47\x0C\x66\x89\x46\x78\x8B\x47", "xxx?xxx?xx");
AddAddress("NoFreeDrive", TMMODULESTART, TMMODULESIZE, (BYTE*)"\xC7\x86\x00\x00\x00\x00\x01\x00\x00\x00\x83\xBE\xA4\x03\x00\x00\x00\x74\x14", "xx????xxxxxx????xxx");
AddAddress("NoGravity", TMMODULESTART, TMMODULESIZE, (BYTE*)"\x89\x7C\x24\x20\xF3\x0F\x11\x46\x28\xF3\x0F\x10\x46\x2C\xF3\x0F\x58\xC3", "xxx?xxxx?xxxx?xxxx", 0x4);
AddAddress("BoostHack", TMMODULESTART, TMMODULESIZE, (BYTE*)"\xF3\x0F\x10\x03\xF3\x0F\x59\x44\x24\x1C\xF3\x0F\x11\x86\x00\x00\x00\x00\x8B\x43\x04\x03\xC7", "xxxxxxxxx?xxxx????xx?xx", 0x4);
AddAddress("CPFix1", TMMODULESTART, TMMODULESIZE, (BYTE*)"\x0F\x83\x00\x00\x00\x00\x8B\x07\x68", "xx????xxx");
AddAddress("CPFix2", TMMODULESTART, TMMODULESIZE, (BYTE*)"\x74\x2E\xFF\xB7\x00\x00\x00\x00\x8B\x8B", "xxxx????xx");
AddAddress("SHHack", TMMODULESTART, TMMODULESIZE, (BYTE*)"\xF3\x0F\x59\x15\x00\x00\x00\x00\xFF\x76\x04\x8B\xCF\xE8\x00\x00\x00\x00\x8B\x0E", "xxxx????xx?xxx????xx", 0x4, true);
AddAddress("Version", TMMODULESTART, TMMODULESIZE, (BYTE*)"\xC7\x44\x24\x00\x00\x00\x00\x00\xC7\x44\x24\x00\x31\x00\x00\x00\xE8\x00\x00\x00\x00\xC7\x44\x24\x00\xFF\xFF\xFF\xFF", "xxx?????xxx?xxxxx????xxx?xxxx", 0x4, true);
AddAddress("NadeoUnlock", TMMODULESTART, TMMODULESIZE, (BYTE*)"\x83\xB8\xEC\x00\x00\x00\x05\x74\x5C", "xxxxxxxxx", 0x7);
AddAddress("NoWallFriction", TMMODULESTART, TMMODULESIZE, (BYTE*)"\xC7\x80\x00\x00\x00\x00\x01\x00\x00\x00\x83\x7E\x00\x00", "xx????xxxxxx?x");
AddAddress("TUVis", TMMODULESTART, TMMODULESIZE, (BYTE*)"\x74\x1C\xC7\x44\x24\x0C\x00\x00\x00\x00\xC7\x44\x24\x10\x14\x00\x00\x00\xE8","xxxxx?????xxx?xxxxx");
AddAddress("TURanking", TMMODULESTART, TMMODULESIZE, (BYTE*)"\x0F\x84\x3B\x01\x00\x00\x8B\x87\xC0\x01\x00\x00\x3B\xC3\x0F\x84", "xx????xxxxxxxxxx");
AddAddress("TUStart", TMMODULESTART, TMMODULESIZE, (BYTE*)"\x74\x2A\xE8\x00\x00\x00\x00\x8B\xCF\xC7\x87\xB0\x0D\x00\x00\x01\x00\x00\x00", "xxx????xxxxxxxxxxxx");
AddAddress("TimeFreezeChange", TMMODULESTART, TMMODULESIZE, (BYTE*)"\x89\x10\x8B\x86\x00\x00\x00\x00\x85\xC0", "xxxx????xx");
AddAddress("TimeFreezeFinishFix", TMMODULESTART, TMMODULESIZE, (BYTE*)"\x74\x2E\xFF\xB7", "xxxx");
/*
Standart Addressen definieren
*/
SetAddress("NoGravity", 0x00FA12CC);
SetAddress("BaseP1", 0x18C1410);
SetAddress("MeterHack", 0x00EF98A7);
SetAddress("NoPlatCount", 0x00CD2DE1);
SetAddress("NoGrasDirt", 0x0064C412);
SetAddress("NoFreeDrive", 0x0064B2FF);
SetAddress("BoostHack", 0x0064B2A3);
SetAddress("CPFix1", 0x00E9ED44);
SetAddress("CPFix2", 0x00E9F0FF);
SetAddress("SHHack", 0x0163FAA8);
SetAddress("Version", 0x0157C96C);
SetAddress("NoWallFriction", 0x0064C3C7);
SetAddress("NadeoUnlock", 0x00D21FF6);
SetAddress("TUVis", 0x00BA6028);
SetAddress("TURanking", 0x00BA6344);
SetAddress("TUStart", 0x00BA64B3);
SetAddress("TimeFreezeChange", 0x00E989EC);
SetAddress("TimeFreezeFinishFix", 0x00E9F0FF);
}
/*! This is called in order to call the correct methods of the datalink
protocols, ie. it will translate address changes to
net_datalink_protocol::change_address(), and IFF_UP changes to
net_datalink_protocol::interface_up(), and interface_down().
Everything else is passed unchanged to net_datalink_protocol::control().
*/
status_t
Interface::Control(net_domain* domain, int32 option, ifreq& request,
ifreq* userRequest, size_t length)
{
switch (option) {
case SIOCSIFFLAGS:
{
if (length != sizeof(ifreq))
return B_BAD_VALUE;
uint32 requestFlags = request.ifr_flags;
uint32 oldFlags = flags;
status_t status = B_OK;
request.ifr_flags &= ~(IFF_UP | IFF_LINK | IFF_BROADCAST);
if ((requestFlags & IFF_UP) != (flags & IFF_UP)) {
if ((requestFlags & IFF_UP) != 0)
status = _SetUp();
else
SetDown();
}
if (status == B_OK) {
// TODO: maybe allow deleting IFF_BROADCAST on the interface
// level?
flags &= IFF_UP | IFF_LINK | IFF_BROADCAST;
flags |= request.ifr_flags;
}
if (oldFlags != flags) {
TRACE("Interface %p: flags changed from %" B_PRIx32 " to %"
B_PRIx32 "\n", this, oldFlags, flags);
notify_interface_changed(this, oldFlags, flags);
}
return status;
}
case B_SOCKET_SET_ALIAS:
{
if (length != sizeof(ifaliasreq))
return B_BAD_VALUE;
RecursiveLocker locker(fLock);
ifaliasreq aliasRequest;
if (user_memcpy(&aliasRequest, userRequest, sizeof(ifaliasreq))
!= B_OK)
return B_BAD_ADDRESS;
InterfaceAddress* address = NULL;
if (aliasRequest.ifra_index < 0) {
if (!domain->address_module->is_empty_address(
(const sockaddr*)&aliasRequest.ifra_addr, false)) {
// Find first address that matches the local address
address = AddressForLocal(domain,
(const sockaddr*)&aliasRequest.ifra_addr);
}
if (address == NULL) {
// Find first address for family
address = FirstForFamily(domain->family);
}
if (address == NULL) {
// Create new on the fly
address = new(std::nothrow) InterfaceAddress(this, domain);
if (address == NULL)
return B_NO_MEMORY;
status_t status = AddAddress(address);
if (status != B_OK) {
delete address;
return status;
}
// Note, even if setting the address failed, the empty
// address added here will still be added to the interface.
address->AcquireReference();
}
} else
address = AddressAt(aliasRequest.ifra_index);
if (address == NULL)
return B_BAD_VALUE;
status_t status = B_OK;
if (!domain->address_module->equal_addresses(
(sockaddr*)&aliasRequest.ifra_addr, address->local)) {
status = _ChangeAddress(locker, address, SIOCSIFADDR,
address->local, (sockaddr*)&aliasRequest.ifra_addr);
}
if (status == B_OK && !domain->address_module->equal_addresses(
(sockaddr*)&aliasRequest.ifra_mask, address->mask)
&& !domain->address_module->is_empty_address(
(sockaddr*)&aliasRequest.ifra_mask, false)) {
status = _ChangeAddress(locker, address, SIOCSIFNETMASK,
address->mask, (sockaddr*)&aliasRequest.ifra_mask);
}
if (status == B_OK && !domain->address_module->equal_addresses(
(sockaddr*)&aliasRequest.ifra_destination,
address->destination)
&& !domain->address_module->is_empty_address(
(sockaddr*)&aliasRequest.ifra_destination, false)) {
status = _ChangeAddress(locker, address,
(domain->address_module->flags
& NET_ADDRESS_MODULE_FLAG_BROADCAST_ADDRESS) != 0
? SIOCSIFBRDADDR : SIOCSIFDSTADDR,
address->destination,
(sockaddr*)&aliasRequest.ifra_destination);
}
address->ReleaseReference();
return status;
}
case SIOCSIFADDR:
case SIOCSIFNETMASK:
case SIOCSIFBRDADDR:
case SIOCSIFDSTADDR:
case SIOCDIFADDR:
{
if (length != sizeof(ifreq))
return B_BAD_VALUE;
RecursiveLocker locker(fLock);
InterfaceAddress* address = NULL;
sockaddr_storage newAddress;
size_t size = max_c(request.ifr_addr.sa_len, sizeof(sockaddr));
if (size > sizeof(sockaddr_storage))
size = sizeof(sockaddr_storage);
if (user_memcpy(&newAddress, &userRequest->ifr_addr, size) != B_OK)
return B_BAD_ADDRESS;
if (option == SIOCDIFADDR) {
// Find referring address - we can't use the hash, as another
// interface might use the same address.
AddressList::Iterator iterator = fAddresses.GetIterator();
while ((address = iterator.Next()) != NULL) {
if (address->domain == domain
&& domain->address_module->equal_addresses(
address->local, (sockaddr*)&newAddress))
break;
}
if (address == NULL)
return B_BAD_VALUE;
} else {
// Just use the first address for this family
address = _FirstForFamily(domain->family);
if (address == NULL) {
// Create new on the fly
address = new(std::nothrow) InterfaceAddress(this, domain);
if (address == NULL)
return B_NO_MEMORY;
status_t status = AddAddress(address);
if (status != B_OK) {
delete address;
return status;
}
// Note, even if setting the address failed, the empty
// address added here will still be added to the interface.
}
}
return _ChangeAddress(locker, address, option,
*address->AddressFor(option),
option != SIOCDIFADDR ? (sockaddr*)&newAddress : NULL);
}
default:
// pass the request into the datalink protocol stack
domain_datalink* datalink = DomainDatalink(domain->family);
if (datalink->first_info != NULL) {
return datalink->first_info->control(
datalink->first_protocol, option, userRequest, length);
}
break;
}
return B_BAD_VALUE;
}
INT_PTR Dlg_MemBookmark::MemBookmarkDialogProc( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
PMEASUREITEMSTRUCT pmis;
PDRAWITEMSTRUCT pdis;
int nSelect;
HWND hList;
int offset = 2;
RECT rcBounds, rcLabel;
switch ( uMsg )
{
case WM_INITDIALOG:
{
GenerateResizes( hwnd );
m_hMemBookmarkDialog = hwnd;
hList = GetDlgItem( m_hMemBookmarkDialog, IDC_RA_LBX_ADDRESSES );
SetupColumns( hList );
// Auto-import bookmark file when opening dialog
if ( g_pCurrentGameData->GetGameID() != 0 )
{
std::string file = RA_DIR_BOOKMARKS + std::to_string( g_pCurrentGameData->GetGameID() ) + "-Bookmarks.txt";
ImportFromFile( file );
}
RestoreWindowPosition( hwnd, "Memory Bookmarks", true, false );
return TRUE;
}
case WM_GETMINMAXINFO:
{
LPMINMAXINFO lpmmi = (LPMINMAXINFO)lParam;
lpmmi->ptMinTrackSize = pDlgMemBookmarkMin;
}
break;
case WM_SIZE:
{
RARect winRect;
GetWindowRect( hwnd, &winRect );
for ( ResizeContent content : vDlgMemBookmarkResize )
content.Resize( winRect.Width(), winRect.Height() );
//InvalidateRect( hwnd, NULL, TRUE );
RememberWindowSize(hwnd, "Memory Bookmarks");
}
break;
case WM_MOVE:
RememberWindowPosition(hwnd, "Memory Bookmarks");
break;
case WM_MEASUREITEM:
pmis = (PMEASUREITEMSTRUCT)lParam;
pmis->itemHeight = 16;
return TRUE;
case WM_DRAWITEM:
{
pdis = (PDRAWITEMSTRUCT)lParam;
// If there are no list items, skip this message.
if ( pdis->itemID == -1 )
break;
switch ( pdis->itemAction )
{
case ODA_SELECT:
case ODA_DRAWENTIRE:
hList = GetDlgItem( hwnd, IDC_RA_LBX_ADDRESSES );
ListView_GetItemRect( hList, pdis->itemID, &rcBounds, LVIR_BOUNDS );
ListView_GetItemRect( hList, pdis->itemID, &rcLabel, LVIR_LABEL );
RECT rcCol ( rcBounds );
rcCol.right = rcCol.left + ListView_GetColumnWidth( hList, 0 );
// Draw Item Label - Column 0
wchar_t buffer[ 512 ];
if ( m_vBookmarks[ pdis->itemID ]->Decimal() )
swprintf_s ( buffer, 512, L"(D)%s", m_vBookmarks[ pdis->itemID ]->Description().c_str() );
else
swprintf_s ( buffer, 512, L"%s", m_vBookmarks[ pdis->itemID ]->Description().c_str() );
if ( pdis->itemState & ODS_SELECTED )
{
SetTextColor( pdis->hDC, GetSysColor( COLOR_HIGHLIGHTTEXT ) );
SetBkColor( pdis->hDC, GetSysColor( COLOR_HIGHLIGHT ) );
FillRect( pdis->hDC, &rcBounds, GetSysColorBrush( COLOR_HIGHLIGHT ) );
}
else
{
SetTextColor( pdis->hDC, GetSysColor( COLOR_WINDOWTEXT ) );
COLORREF color;
if ( m_vBookmarks[ pdis->itemID ]->Frozen() )
color = RGB( 255, 255, 160 );
else
color = GetSysColor( COLOR_WINDOW );
HBRUSH hBrush = CreateSolidBrush( color );
SetBkColor( pdis->hDC, color );
FillRect( pdis->hDC, &rcBounds, hBrush );
DeleteObject( hBrush );
}
if ( wcslen( buffer ) > 0 )
{
rcLabel.left += ( offset / 2 );
rcLabel.right -= offset;
DrawTextW( pdis->hDC, buffer, wcslen( buffer ), &rcLabel, DT_SINGLELINE | DT_LEFT | DT_NOPREFIX | DT_NOCLIP | DT_VCENTER | DT_END_ELLIPSIS );
}
// Draw Item Label for remaining columns
LV_COLUMN lvc;
lvc.mask = LVCF_FMT | LVCF_WIDTH;
for ( size_t i = 1; ListView_GetColumn( hList, i, &lvc ); ++i )
{
rcCol.left = rcCol.right;
rcCol.right += lvc.cx;
switch ( i )
{
case CSI_ADDRESS:
swprintf_s ( buffer, 512, L"%06x", m_vBookmarks[ pdis->itemID ]->Address() );
break;
case CSI_VALUE:
if ( m_vBookmarks[ pdis->itemID ]->Decimal() )
swprintf_s ( buffer, 512, L"%u", m_vBookmarks[ pdis->itemID ]->Value() );
else
{
switch ( m_vBookmarks[ pdis->itemID ]->Type() )
{
case 1: swprintf_s ( buffer, 512, L"%02x", m_vBookmarks[ pdis->itemID ]->Value() ); break;
case 2: swprintf_s ( buffer, 512, L"%04x", m_vBookmarks[ pdis->itemID ]->Value() ); break;
case 3: swprintf_s ( buffer, 512, L"%08x", m_vBookmarks[ pdis->itemID ]->Value() ); break;
}
}
break;
case CSI_PREVIOUS:
if ( m_vBookmarks[ pdis->itemID ]->Decimal() )
swprintf_s ( buffer, 512, L"%u", m_vBookmarks[ pdis->itemID ]->Previous() );
else
{
switch ( m_vBookmarks[ pdis->itemID ]->Type() )
{
case 1: swprintf_s ( buffer, 512, L"%02x", m_vBookmarks[ pdis->itemID ]->Previous() ); break;
case 2: swprintf_s ( buffer, 512, L"%04x", m_vBookmarks[ pdis->itemID ]->Previous() ); break;
case 3: swprintf_s ( buffer, 512, L"%08x", m_vBookmarks[ pdis->itemID ]->Previous() ); break;
}
}
break;
case CSI_CHANGES:
swprintf_s ( buffer, 512, L"%d", m_vBookmarks[ pdis->itemID ]->Count() );
break;
default:
swprintf_s ( buffer, 512, L"" );
break;
}
if ( wcslen( buffer ) == 0 )
continue;
UINT nJustify = DT_LEFT;
switch ( lvc.fmt & LVCFMT_JUSTIFYMASK )
{
case LVCFMT_RIGHT:
nJustify = DT_RIGHT;
break;
case LVCFMT_CENTER:
nJustify = DT_CENTER;
break;
default:
break;
}
rcLabel = rcCol;
rcLabel.left += offset;
rcLabel.right -= offset;
DrawTextW( pdis->hDC, buffer, wcslen( buffer ), &rcLabel, nJustify | DT_SINGLELINE | DT_NOPREFIX | DT_VCENTER | DT_END_ELLIPSIS );
}
//if (pdis->itemState & ODS_SELECTED) //&& (GetFocus() == this)
// DrawFocusRect(pdis->hDC, &rcBounds);
break;
case ODA_FOCUS:
break;
}
return TRUE;
}
case WM_NOTIFY:
{
switch ( LOWORD( wParam ) )
{
case IDC_RA_LBX_ADDRESSES:
if ( ( (LPNMHDR)lParam )->code == NM_CLICK )
{
hList = GetDlgItem( hwnd, IDC_RA_LBX_ADDRESSES );
nSelect = ListView_GetNextItem( hList, -1, LVNI_FOCUSED );
if ( nSelect == -1 )
break;
}
else if ( ( (LPNMHDR)lParam )->code == NM_DBLCLK )
{
hList = GetDlgItem( hwnd, IDC_RA_LBX_ADDRESSES );
LPNMITEMACTIVATE pOnClick = (LPNMITEMACTIVATE)lParam;
if ( pOnClick->iItem != -1 && pOnClick->iSubItem == CSI_DESC )
{
nSelItemBM = pOnClick->iItem;
nSelSubItemBM = pOnClick->iSubItem;
EditLabel ( pOnClick->iItem, pOnClick->iSubItem );
}
else if ( pOnClick->iItem != -1 && pOnClick->iSubItem == CSI_ADDRESS )
{
g_MemoryDialog.SetWatchingAddress( m_vBookmarks[ pOnClick->iItem ]->Address() );
MemoryViewerControl::setAddress( ( m_vBookmarks[ pOnClick->iItem ]->Address() &
~( 0xf ) ) - ( (int)( MemoryViewerControl::m_nDisplayedLines / 2 ) << 4 ) + ( 0x50 ) );
}
}
}
return TRUE;
}
case WM_COMMAND:
{
switch ( LOWORD( wParam ) )
{
case IDOK:
case IDCLOSE:
case IDCANCEL:
EndDialog( hwnd, true );
return TRUE;
case IDC_RA_ADD_BOOKMARK:
{
if ( g_MemoryDialog.GetHWND() != nullptr )
AddAddress();
return TRUE;
}
case IDC_RA_DEL_BOOKMARK:
{
HWND hList = GetDlgItem( hwnd, IDC_RA_LBX_ADDRESSES );
int nSel = ListView_GetNextItem( hList, -1, LVNI_SELECTED );
if ( nSel != -1 )
{
while ( nSel >= 0 )
{
MemBookmark* pBookmark = m_vBookmarks[ nSel ];
// Remove from vector
m_vBookmarks.erase( m_vBookmarks.begin() + nSel );
// Remove from map
std::vector<const MemBookmark*> *pVector;
pVector = &m_BookmarkMap.find( pBookmark->Address() )->second;
pVector->erase( std::find( pVector->begin(), pVector->end(), pBookmark ) );
if ( pVector->size() == 0 )
m_BookmarkMap.erase( pBookmark->Address() );
delete pBookmark;
ListView_DeleteItem( hList, nSel );
nSel = ListView_GetNextItem( hList, -1, LVNI_SELECTED );
}
InvalidateRect( hList, NULL, FALSE );
}
return TRUE;
}
case IDC_RA_FREEZE:
{
if ( m_vBookmarks.size() > 0 )
{
hList = GetDlgItem( hwnd, IDC_RA_LBX_ADDRESSES );
unsigned int uSelectedCount = ListView_GetSelectedCount( hList );
if ( uSelectedCount > 0 )
{
for ( int i = ListView_GetNextItem( hList, -1, LVNI_SELECTED ); i >= 0; i = ListView_GetNextItem( hList, i, LVNI_SELECTED ) )
m_vBookmarks[ i ]->SetFrozen( !m_vBookmarks[ i ]->Frozen() );
}
ListView_SetItemState( hList, -1, LVIF_STATE, LVIS_SELECTED );
}
return TRUE;
}
case IDC_RA_CLEAR_CHANGE:
{
if ( m_vBookmarks.size() > 0 )
{
hList = GetDlgItem( hwnd, IDC_RA_LBX_ADDRESSES );
int idx = -1;
for ( MemBookmark* bookmark : m_vBookmarks )
{
idx++;
bookmark->ResetCount();
}
InvalidateRect( hList, NULL, FALSE );
}
return TRUE;
}
case IDC_RA_DECIMALBOOKMARK:
{
if ( m_vBookmarks.size() > 0 )
{
hList = GetDlgItem( hwnd, IDC_RA_LBX_ADDRESSES );
unsigned int uSelectedCount = ListView_GetSelectedCount( hList );
if ( uSelectedCount > 0 )
{
for ( int i = ListView_GetNextItem( hList, -1, LVNI_SELECTED ); i >= 0; i = ListView_GetNextItem( hList, i, LVNI_SELECTED ) )
m_vBookmarks[ i ]->SetDecimal( !m_vBookmarks[ i ]->Decimal() );
}
ListView_SetItemState( hList, -1, LVIF_STATE, LVIS_SELECTED );
}
return TRUE;
}
case IDC_RA_SAVEBOOKMARK:
{
ExportJSON();
return TRUE;
}
case IDC_RA_LOADBOOKMARK:
{
std::string file = ImportDialog();
if (file.length() > 0 )
ImportFromFile( file );
return TRUE;
}
default:
return FALSE;
}
}
default:
break;
}
return FALSE;
}
void CContactListCtrl::OnAddAddress(wxCommandEvent& e)
{
AddAddress();
}
void cTrackManiaHack::DefineAddresses(void)
{
const DWORD TMMODULESTART = 0x00401000;
const DWORD TMMODULESIZE = 0x00727000;
m_vecAddresses.clear();
AddAddress("BaseP1", TMMODULESTART, TMMODULESIZE, (PBYTE)"\x8B\x0D\x00\x00\x00\x00\x51\xFF\xD0\x83\xC4\x08\x39\x35\x00\x00\x00\x00\x76\x76\x39\x75\x08\x74\x43", "xx????xxxxxxxx????xxxxxxx", 0x2, true);
AddAddress("BaseP3", TMMODULESTART, TMMODULESIZE, (PBYTE)"\x8B\x0D\x00\x00\x00\x00\x57\x6A\x04\xE8", "xx????xxxx", 0x2, true);
AddAddress("MeterHack1", TMMODULESTART, TMMODULESIZE, (PBYTE)"\x89\x86\x00\x00\x00\x00\x8B\x8F\x00\x00\x00\x00\x89\x8E\x00\x00\x00\x00\xD9\x6C\x24\x14", "xx????xx????xx????xxxx");
AddAddress("MeterHack2", TMMODULESTART, TMMODULESIZE, (PBYTE)"\x89\xB3\x00\x00\x00\x00\x89\xB3\x00\x00\x00\x00\x89\xB3\x00\x00\x00\x00\x39\xB5\x00\x00\x00\x00", "xx????xx????xx????xx????");
AddAddress("TimeCheckpointChange", TMMODULESTART, TMMODULESIZE, (PBYTE)"\x8B\x10\x89\x96\x00\x00\x00\x00\x5E\xC2\x04\x00", "xxxx????xxxx", 0x2, false);
AddAddress("TimeNormalChange", TMMODULESTART, TMMODULESIZE, (PBYTE)"\x89\x8D\x00\x00\x00\x00\x8B\x86\x00\x00\x00\x00\x85\xC0\x74\x05", "xx????xx????xxxx");
AddAddress("NoGrasDirt", TMMODULESTART, TMMODULESIZE, (PBYTE)"\x66\x89\x86\x28\x01\x00\x00\x8B\x4F\x40\x85\xC9", "xxxxxxxxxxxx");
AddAddress("BoostHack", TMMODULESTART, TMMODULESIZE, (PBYTE)"\xD8\x4C\x24\x20\x8B\x00\x51\x6A\x01", "xxxxxxxxx"); // im Prinzip 2x vorhanden. Allerdings wird nur die erste benutzt, die in dem fall die richtige ist. Liegt daran, dass es noch den Turbo mit ID: 1A gibt
AddAddress("DisableWallFriction", TMMODULESTART, TMMODULESIZE, (PBYTE)"\x89\x8B\x00\x00\x00\x00\xD9\x47\x18", "xx????xxx");
AddAddress("DisableFreeDrive", TMMODULESTART, TMMODULESIZE, (PBYTE)"\xC7\x86\x00\x00\x00\x00\x00\x00\x00\x00\x55\x8B\xCE", "xx????????xxx");
AddAddress("PlatformTriesCounter", TMMODULESTART, TMMODULESIZE, (PBYTE)"\x83\x87\xC4\x02\x00\x00\x01\x8B\x87\x00\x00\x00\x00", "xxxxxxxxx????");
AddAddress("CheckpointFix1", TMMODULESTART, TMMODULESIZE, (PBYTE)"\x0F\x83\x00\x00\x00\x00\x8B\x06\x8B\x50\x10", "xx????xxxxx");
AddAddress("CheckpointFix2", TMMODULESTART, TMMODULESIZE, (PBYTE)"\x89\x9F\x00\x00\x00\x00\xE9\x00\x00\x00\x00\x8B\x8E", "xx????x????xx");
AddAddress("NoRestrictions", TMMODULESTART, TMMODULESIZE, (PBYTE)"\x0F\x85\x00\x00\x00\x00\x68\x00\x00\x00\x00\xB9\x00\x00\x00\x00\xE8\x00\x00\x00\x00\x50\x8D\x4C\x24\x14\xE8\x00\x00\x00\x00\x53\x8D\x8E", "xx????x????x????x????xxxxxx????xxx");
AddAddress("NoTrackPassword", TMMODULESTART, TMMODULESIZE, (PBYTE)"\x0F\x85\x00\x00\x00\x00\x8B\x07\x8B\x88\x00\x00\x00\x00\x85\xC9", "xx????xxxx????xx");
AddAddress("Version", TMMODULESTART, TMMODULESIZE, (PBYTE)"\x8B\x15\x00\x00\x00\x00\x89\x54\x24\x48\xEB\x04", "xx????xxxxxx", 0x2, true);
AddAddress("NadeoGhosts",TMMODULESTART, TMMODULESIZE, (PBYTE)"\x75\x0D\x83\xC6\x01\x3B\xF3\x72\xD5", "xxxxxxxxx");
AddAddress("UnlockTrackPictures", TMMODULESTART, TMMODULESIZE, (PBYTE)"\x74\x25\x8D\x4C\x24\x04\x51\x8B\x4C\x24\x18", "xxxxxxxxxxx");
AddAddress("UnlockAllTracks", TMMODULESTART, TMMODULESIZE, (PBYTE)"\x74\x47\x89\xBE\x00\x00\x00\x00\xBB", "xxxx????x");
AddAddress("GroundNumBase", 0x00D5772C);
AddAddress("NoGravity", 0x0053346C);
SetAddress("BaseP1", 0x00d74518);
SetAddress("BaseP3", 0x00d76a7c);
SetAddress("MeterHack1", 0x0047F71D);
SetAddress("MeterHack2", 0x00483035);
SetAddress("TimeCheckpointChange", 0x0047af30);
SetAddress("TimeNormalChange", 0x0047d919);
SetAddress("NoGrasDirt", 0x007C0D95);
SetAddress("BoostHack", 0x007C6DE9);
SetAddress("DisableWallFriction", 0x007C0D2E);
SetAddress("DisableFreeDrive", 0x007C6EEC);
SetAddress("PlatformTriesCounter", 0x0047BEEF);
SetAddress("CheckpointFix1", 0x0048066A);
SetAddress("CheckpointFix2", 0x00480A55);
SetAddress("NoRestrictions", 0x00686EB8);
SetAddress("NoTrackPassword", 0x00495BDA);
SetAddress("NadeoGhosts", 0x004BD442);
SetAddress("UnlockTrackPictures", 0x004EA05D);
SetAddress("UnlockAllTracks", 0x004EC235);
}
