Anyone happen to know how all these values are gathered? a packet log of SSHR returns:
Processors: 01 00 00 00
Architecture: 00 00 00 00
Level: 06 00 00 00
Timing: 00 05 00 00
Phys Mem: 00 04 00 00
Page Mem: FF 0F 00 00
Free Disk: 17 0F 00 00
I've used a few API calls, but I can't get all the data to show up the same. Using GetSystemInfo, I can get the processor count, what i think is the architecture (dwOemID), and nothing else. using GetDiskFreeSpaceExA gets me nothing, since my free disk space is too big for a long to handle. Physical and page file memory much the same. Anybody got a clue as to how to get this data?
Page Mem is 4095, which suggests to me that it's telling Blizzard your process memory, 4gb.
Free Disk is 3863. Does your disk have a 1024-multiple of that available?
I have 53,062,500,352 bytes free on my primary hard drive. Not divisible by 3863 evenly. My page file is set to 4095 megs, and I apparently can get that through dwPageSize with GetSystemInfo. I can also get the RAM size. Any idea about the other values?
Edit: Ran it again and got a Timing of B8 0B 00 00 this time.
So, to make it more clear, I still need to determine the Level, Timing, and Disk space.
Isn't this what msdn is for? All of this data should be easily available through some api call, which I dunno off the top of my head except the ones you listed. BUT YOU SHOULD BE ABLE TO FIND THIS SHIT ;)
GetSystemInfo, GlobalMemoryStatus, GetDiskFreeSpace should be sufficient enough to build the packet.
You'd think it would. But like I said, the client returns 3863 for the hard drive free space when it was 53,062,500,352 bytes, and I can't find any divisors to get that result reliably. There's also no Processor Level or Timing variables in any APIs I can find.
Quote from: [RealityRipple] on February 07, 2007, 06:24 PM
You'd think it would. But like I said, the client returns 3863 for the hard drive free space when it was 53,062,500,352 bytes, and I can't find any divisors to get that result reliably. There's also no Processor Level or Timing variables in any APIs I can find.
Perhaps it might be more productive to analyze how an actual game client builds this message?
How would I go about doing that? I have no knowledge in current day assembly (I only know MONITOR for the Commodore 64 and 128). If I did, I'd be working on Lockdown, not a packet that only one ancient client uses.
Quote from: [RealityRipple] on February 07, 2007, 07:59 PM
How would I go about doing that? I have no knowledge in current day assembly (I only know MONITOR for the Commodore 64 and 128). If I did, I'd be working on Lockdown, not a packet that only one ancient client uses.
Then perhaps you should be spending your time on something else, but like I said, GetDiskFreeSpace will give you what you need for the last part of that message.
Quote from: [RealityRipple] on February 07, 2007, 07:59 PM
How would I go about doing that? I have no knowledge in current day assembly (I only know MONITOR for the Commodore 64 and 128). If I did, I'd be working on Lockdown, not a packet that only one ancient client uses.
There is no time like the present to learn.
I would recommend getting yourself a diassembler (http://www.datarescue.be/idafreeware/freeida43.exe), a debugger (http://www.microsoft.com/whdc/devtools/debugging/installx86.mspx) (includes extensive documentation and some tutorials and walkthroughs on various real world debugging scenarios), and some x86 assembly language documentation (http://www.intel.com/products/processor/manuals/). Some documentation on Win32 calling conventions (http://www.nynaeve.net/?p=66) would additionally be useful, as you're likely just going to need to figure out some simple calls to standard Win32 functions. You can find information on Win32 APIs online at MSDN (http://msdn2.microsoft.com/en-us/library/default.aspx).
All of the above are freely available, and spending a short time learning how to use them will be the start of building some valuable skills for a software development job to boot.
Thank you for the links Sky, I'll check em out when my computer isn't being such a little bitch and I can replace the RAM that's been corrupted.
UserLoser, GetDiskFreeSpace returns: 8 sectors per cluster , 512 bytes per sector , 16038174 free clusters , 29302552 total clusters, and SSHR now gives me 1F 0F 00 00 (I reformatted completely last night, so the numbers are a bit different now). 1F 0F 00 00 means 3871, right? I still don't see how it gets the value...
Well that's nice... I now get DF 05 00 00 (1503) for a page file size, since I set my page file to be anywhere from 1024 megs to 4095 megs. The GetSystemInfo API returns 4096, though. Guess I'll have to wait till I can disassemble it myself.
IIRC, performs math on sectors per cluster, bytes per sector, and free clusters, not sure though.
I've tried bytes per sector * sectors per cluster * free clusters, which gives me 65692360704 free bytes total. Divide that by 3871 to see if there's any multiple there, and you get 16970385.095324205631619736502196. Definitely not an even multiple. I've tried other such combinations of the values, and gotten nothing that links 3871. If I'm doing something wrong, I'd really like to know.
Well, if i use the non-standard SYSTEM_INFO definition, I can get the Processor Level, but I still can't figure out the timing or how to get the correct hard drive info. The disassembler is too big for me to download on dial up, so that's not really an option for me at the moment.
I've tried a few logs to figure out what the timing is, and it started at 2840, went up to 2850 the next time, then 2860, 2870, and back down to 2850. I'm a bit confused as to what it is...
I just added 12 gb of useless data [10% of my total drive space] (using the DOS DEBUG command), and the "Free Disk Space" didn't change at all. It's still at 1F 0F 00 00, like it's been since I reformatted. It's either the total disk size, or not hard drive related at all.
Edit: Used Partition Magic to remove about 1 GB (1077514240 bytes). Total sectors dropped from 29302552 to 29039487 (263065 sector difference). the Disk Space field went from 1F 0F 00 00 to 1B 0B 00 00. This isn't making much sense to me... since if you divide the sector difference (263065) by the field difference (1028 [3871-2843 {F1F-B1B}]), you get a bit under 256. it would then make sense that if you multiply 256 by the current Field (2843 [B1B]), you would get the current number of sectors, which is 29039487. Instead, you get 727808....
Am I doing something completely wrong here?
I am pretty sure there were some bit shifting used in calculating this value.
...Any further information on that would be much appreciated.
Quote from: [RealityRipple] on February 11, 2007, 01:57 AM
...Any further information on that would be much appreciated.
See: battle.snp
Wow. I am in Battle.snp and its got some crazy/stupid crap >.<
.text:19014006 loc_19014006: ; CODE XREF: sub_19013FD0+49j
.text:19014006 add eax, ebx
.text:19014008 add eax, ebx
.text:1901400A add eax, ebx
.text:1901400C add eax, ebx
.text:1901400E add eax, ebx
.text:19014010 add eax, ebx
.text:19014012 add eax, ebx
.text:19014014 add eax, ebx
.text:19014016 add eax, ebx
.text:19014018 dec ecx
.text:19014019 jnz short loc_19014006
Who in there right freakin mind does crap like that!?!?!?!?
~Hdx
.text:19013FD0
.text:19013FD0 ; ¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦ S U B R O U T I N E ¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦
.text:19013FD0
.text:19013FD0 ; Attributes: bp-based frame
.text:19013FD0
.text:19013FD0 sub_19013FD0 proc near ; CODE XREF: sub_19013010:loc_190131F2p
.text:19013FD0
.text:19013FD0 RootPathName = byte ptr -174h
.text:19013FD0 SystemInfo = _SYSTEM_INFO ptr -70h
.text:19013FD0 Buffer = _MEMORYSTATUS ptr -4Ch
.text:19013FD0 var_2C = dword ptr -2Ch
.text:19013FD0 var_28 = dword ptr -28h
.text:19013FD0 var_24 = dword ptr -24h
.text:19013FD0 var_20 = dword ptr -20h
.text:19013FD0 var_1C = dword ptr -1Ch
.text:19013FD0 var_18 = dword ptr -18h
.text:19013FD0 var_14 = dword ptr -14h
.text:19013FD0 NumberOfFreeClusters= dword ptr -10h
.text:19013FD0 SectorsPerCluster= dword ptr -0Ch
.text:19013FD0 TotalNumberOfClusters= dword ptr -8
.text:19013FD0 BytesPerSector = dword ptr -4
.text:19013FD0
.text:19013FD0 push ebp
.text:19013FD1 mov ebp, esp
.text:19013FD3 sub esp, 174h
.text:19013FD9 push ebx
.text:19013FDA push esi
.text:19013FDB push edi
.text:19013FDC mov edi, ds:GetTickCount
.text:19013FE2 call edi ; GetTickCount
.text:19013FE4 mov ebx, eax
.text:19013FE6 call edi ; GetTickCount
.text:19013FE8 mov esi, eax
.text:19013FEA cmp esi, ebx
.text:19013FEC jnz short loc_19013FF6
.text:19013FEE
.text:19013FEE loc_19013FEE: ; CODE XREF: sub_19013FD0+24j
.text:19013FEE call edi ; GetTickCount
.text:19013FF0 mov esi, eax
.text:19013FF2 cmp esi, ebx
.text:19013FF4 jz short loc_19013FEE
.text:19013FF6
.text:19013FF6 loc_19013FF6: ; CODE XREF: sub_19013FD0+1Cj
.text:19013FF6 xor ebx, ebx
.text:19013FF8 call edi ; GetTickCount
.text:19013FFA sub eax, esi
.text:19013FFC cmp eax, 32h
.text:19013FFF jnb short loc_19014025
.text:19014001
.text:19014001 loc_19014001: ; CODE XREF: sub_19013FD0+53j
.text:19014001 mov ecx, 2710h
.text:19014006
.text:19014006 loc_19014006: ; CODE XREF: sub_19013FD0+49j
.text:19014006 add eax, ebx
.text:19014008 add eax, ebx
.text:1901400A add eax, ebx
.text:1901400C add eax, ebx
.text:1901400E add eax, ebx
.text:19014010 add eax, ebx
.text:19014012 add eax, ebx
.text:19014014 add eax, ebx
.text:19014016 add eax, ebx
.text:19014018 dec ecx
.text:19014019 jnz short loc_19014006
.text:1901401B inc ebx
.text:1901401C call edi ; GetTickCount
.text:1901401E sub eax, esi
.text:19014020 cmp eax, 32h
.text:19014023 jb short loc_19014001
.text:19014025
.text:19014025 loc_19014025: ; CODE XREF: sub_19013FD0+2Fj
.text:19014025 lea eax, [ebp+SystemInfo]
.text:19014028 push eax ; lpSystemInfo
.text:19014029 call ds:GetSystemInfo
.text:1901402F lea ecx, [ebp+Buffer]
.text:19014032 mov [ebp+Buffer.dwLength], 20h
.text:19014039 push ecx ; lpBuffer
.text:1901403A call ds:GlobalMemoryStatus
.text:19014040 lea edx, [ebp+RootPathName]
.text:19014046 push 104h ; nSize
.text:1901404B push edx ; lpFilename
.text:1901404C push 0 ; hModule
.text:1901404E call ds:GetModuleFileNameA
.text:19014054 lea eax, [ebp+TotalNumberOfClusters]
.text:19014057 lea ecx, [ebp+NumberOfFreeClusters]
.text:1901405A push eax ; lpTotalNumberOfClusters
.text:1901405B lea edx, [ebp+BytesPerSector]
.text:1901405E push ecx ; lpNumberOfFreeClusters
.text:1901405F lea eax, [ebp+SectorsPerCluster]
.text:19014062 push edx ; lpBytesPerSector
.text:19014063 lea ecx, [ebp+RootPathName]
.text:19014069 push eax ; lpSectorsPerCluster
.text:1901406A push ecx ; lpRootPathName
.text:1901406B mov byte ptr [ebp-171h], 0
.text:19014072 call ds:GetDiskFreeSpaceA
.text:19014078 mov eax, dword ptr [ebp+SystemInfo.anonymous_0]
.text:1901407B mov edx, [ebp+SystemInfo.dwNumberOfProcessors]
.text:1901407E and eax, 0FFFFh
.text:19014083 mov [ebp+var_2C], edx
.text:19014086 mov [ebp+var_28], eax
.text:19014089 lea edx, [ebx+ebx+5]
.text:1901408D mov eax, 0CCCCCCCDh
.text:19014092 mov ecx, dword ptr [ebp+SystemInfo.wProcessorLevel]
.text:19014095 mul edx
.text:19014097 shr edx, 3
.text:1901409A and ecx, 0FFFFh
.text:190140A0 push 1Ch
.text:190140A2 lea eax, [edx+edx*4]
.text:190140A5 mov edx, [ebp+Buffer.dwTotalPageFile]
.text:190140A8 shl eax, 1
.text:190140AA mov [ebp+var_20], eax
.text:190140AD mov eax, [ebp+TotalNumberOfClusters]
.text:190140B0 imul eax, [ebp+BytesPerSector]
.text:190140B4 imul eax, [ebp+SectorsPerCluster]
.text:190140B8 mov [ebp+var_24], ecx
.text:190140BB mov ecx, [ebp+Buffer.dwTotalPhys]
.text:190140BE add ecx, 0A0000h
.text:190140C4 shr ecx, 14h
.text:190140C7 shr edx, 14h
.text:190140CA mov [ebp+var_1C], ecx
.text:190140CD mov [ebp+var_18], edx
.text:190140D0 shr eax, 14h
.text:190140D3 lea edx, [ebp+var_2C]
.text:190140D6 mov cl, 2Bh
.text:190140D8 mov [ebp+var_14], eax
.text:190140DB call SendBNCSMessage
.text:190140E0 pop edi
.text:190140E1 pop esi
.text:190140E2 pop ebx
.text:190140E3 mov esp, ebp
.text:190140E5 pop ebp
.text:190140E6 retn
.text:190140E6 sub_19013FD0 endp
.text:190140E6
~Hdx
For those of you using vb... that converts to
FirstTick = GetTickCount
Do
CurrentTick = GetTickCount
Loop While CurrentTick = FirstTick
ProcessorSpeed = GetTickCount - CurrentTick
Do
For I = 10000 To 0 Step -1
ProcessorSpeed = ProcessorSpeed + Counter + Counter + Counter + Counter_
+ Counter + Counter + Counter + Counter
Counter = Counter + 1
Next I
ProcessorSpeed = GetTickCount - CurrentTick
Loop While ProcessorSpeed < &H32
Still working on the drive size issue...
Figured it out. If there's a better way to do the Hard Drive size thing in vb, I'd LOVE to know. This way seems so crappy, but it works.
Private Declare Function GetTickCount Lib "kernel32" () As Long
Private Declare Sub GetSystemInfo Lib "kernel32" (lpSystemInfo As SYSTEM_INFO)
Private Declare Sub GlobalMemoryStatus Lib "kernel32" (lpBuffer As MEMORYSTATUS)
Private Declare Function GetDiskFreeSpaceA Lib "kernel32"_
(ByVal lpRootPathName As String, lpSectorsPerCluster As Long,_
lpBytesPerSector As Long, lpNumberOfFreeClusters As Long, lpTotalNumberOfClusters As Long) As Long
Private Type SYSTEM_INFO
wProcessorArchitecture As Integer
wReserved As Integer
dwPageSize As Long
lpMinimumApplicationAddress As Long
lpMaximumApplicationAddress As Long
dwActiveProcessorMask As Long
dwNumberOfProcessors As Long
dwProcessorType As Long
dwAllocationGranularity As Long
wProcessorLevel As Integer
wProcessorRevision As Integer
End Type
Private Type MEMORYSTATUS
dwLength As Long
dwMemoryLoad As Long
dwTotalPhys As Long
dwAvailPhys As Long
dwTotalPageFile As Long
dwAvailPageFile As Long
dwTotalVirtual As Long
dwAvailVirtual As Long
End Type
Public Sub GetSysInfo(ByRef ProcCount As Long, ByRef ProcArch As Long,_
ByRef ProcLev As Long, ByRef ProcTime As Long, ByRef TotalMem As Long,_
ByRef PageFile As Long, ByRef DiskSpace As Long)
Dim Mem As MEMORYSTATUS
Dim sys As SYSTEM_INFO
Dim DrSize As Double
Dim SperC As Long
Dim BperS As Long
Dim Free As Long
Dim Total As Long
Dim FirstTick As Long
Dim CurrentTick As Long
Dim ProcessorSpeed As Double
Dim Counter As Long
Dim I As Integer
FirstTick = GetTickCount
Do
CurrentTick = GetTickCount
Loop While CurrentTick = FirstTick
ProcessorSpeed = GetTickCount - CurrentTick
Do
For I = 10000 To 0 Step -1
ProcessorSpeed = ProcessorSpeed + Counter + Counter + Counter + Counter_
+ Counter + Counter + Counter + Counter
Counter = Counter + 1
Next I
ProcessorSpeed = GetTickCount - CurrentTick
Loop While ProcessorSpeed < &H32
GetSystemInfo sys
GlobalMemoryStatus Mem
GetDiskFreeSpaceA Left$(App.Path, 3), SperC, BperS, Free, Total
DrSize = CDbl(Total) * SperC * BperS
ProcCount = sys.dwNumberOfProcessors
ProcArch = sys.wProcessorArchitecture
ProcLev = sys.wProcessorLevel
ProcTime = ProcessorSpeed
PageFile = RShift(CDbl(Mem.dwTotalPageFile), &H14)
TotalMem = RShift(CDbl(Mem.dwTotalPhys), &H16)
DiskSpace = CDbl("&H" & Right$(Hex$(RShift(DrSize, &H14)), 3))
End Sub
Private Function RShift(ByVal pnValue As Double, ByVal pnShift As Long) As Long
Dim Shft As String
Shft = Str$(pnValue / (2 ^ pnShift))
If InStr(Shft, ".") > 0 Then
RShift = CLng(Left$(Shft, InStr(Shft, ".") - 1))
Else
RShift = CLng(Shft)
End If
End Function
edit: i havent said anything productive :(
RealityRipple forgot to comment that UserLoser wrote that code initially in C++ before RealityRipple crappily converted it to VB after UserLoser reversed the function in Starcraft Shareware's battle.snp for about five minutes last night then sent the resulting code to Hdx on AIM.
It looks like you guys never validated my processor timing calculation either and are just using my priliminary code that was untested, good job.
Actually, I already added you to the credits in my bot last night for it... but I guess I should thank you on here. The processor timing code gives me 62 almost every time I run it, which seems way too fast compared to the client's result, but seeing as I still don't know assembly (and can't download anything from Skywing's post due to my 1.5 kb/s dial up), I can't help myself.
One other question: on my RShift function, i know it should be div (\), not divide (/), but div can't handle large numbers like hard drive sizes. Is there any OTHER way to cut off decimals without rounding up besides the crappy way I made at 4 AM last night?
Quote from: [RealityRipple] on February 11, 2007, 03:13 PM
Actually, I already added you to the credits in my bot last night for it... but I guess I should thank you on here. The processor timing code gives me 62 almost every time I run it, which seems way too fast compared to the client's result, but seeing as I still don't know assembly (and can't download anything from Skywing's post due to my 1.5 kb/s dial up), I can't help myself.
One other question: on my RShift function, i know it should be div (\), not divide (/), but div can't handle large numbers like hard drive sizes. Is there any OTHER way to cut off decimals without rounding up besides the crappy way I made at 4 AM last night?
Should have already been there if you use BnetDocs. There are some ways yes, but can get messy
I already have a thank-you to "The Staff and Members of BNetDocs...", but now you're specifically thanked. So is the way I did it the best way in the limited language I'm using? I really need to learn more PowerBasic....