//========================================= // allocMem //========================================= public void allocMem(uint pHeap, uint pBlock, uint blockSize, HaloWarsMem.BALContext context) { SymbolInfo.LookupInfo li = new SymbolInfo.LookupInfo(); for (int i = 0; i < context.mBackTraceSize; i++) { HaloWarsMem.getSymbolInfo().lookup(context.mBackTrace[i], ref li); if (HaloWarsMem.getSymbolInfo().isIgnoreSymbol(Path.GetFileName(li.mFilename))) { continue; } if (mBlockToFile.Contains(pBlock)) { GlobalErrors.addError("HeapAlloc : Multiple Allocations of block 0x" + pBlock.ToString("x") + " in heap 0x" + pHeap.ToString("x")); return; } FileAlloc fa = (FileAlloc)mAllocations[li.mFilename]; if (fa == null) { fa = new FileAlloc(li.mFilename); mAllocations.Add(li.mFilename, fa); } mBlockToFile.Add(pBlock, li.mFilename); fa.allocMem(pHeap, pBlock, blockSize, (uint)li.mLine, context); break; } mNumNews++; }
//============================================================================== // deleteMem //============================================================================== public void deleteMem(uint pBlock) { if (!mAllocations.Contains(pBlock)) { GlobalErrors.addError(" LineAlloc : Stray Delete of block 0x" + pBlock.ToString("x")); return; } mTotalBytes -= ((BlockAlloc)mAllocations[pBlock]).mBlockSize; mAllocations.Remove(pBlock); }
//============================================================================ // registerHeap //============================================================================ static public void registerHeap(HaloWarsMem.BALPacketRegisterHeap pkt) { HeapAlloc pHeap = getHeapFromBasePtr(pkt.mPtr); if (pHeap != null) { //ALREADY HAVE THIS HEAP!! GlobalErrors.addError("Multiple allocations of heap 0x" + pkt.mPtr.ToString("x")); return; } HeapAlloc hm = new HeapAlloc(pkt.mPtr, pkt.mFlags, pkt.mName); mRegisteredHeaps.Add(hm); }
private void timer1_Tick(object sender, EventArgs e) { string str = GlobalErrors.popError(); while (str != "") { errorListBox.Items.Add(str); str = GlobalErrors.popError(); if (errorListBox.Items.Count > 100) { errorListBox.Items.Add("Erros exceeds 100. Stopping logging"); timer1.Enabled = false; return; } } }
//============================================================================== // deleteMem //============================================================================== public void deleteMem(uint pBlock) { LineAlloc la = getLineContaining(pBlock); mBlockToLineNum.Remove(pBlock); if (la != null) { mTotalBytes -= la.getBlockSize(pBlock); la.deleteMem(pBlock); if (la.getTotalAllocatedBytes() == 0) { mAllocations.Remove(la); } return; } GlobalErrors.addError("FileAlloc : Stray Delete of block 0x" + pBlock.ToString("x")); }
//========================================= // allocMem //========================================= public void allocMem(uint pHeap, uint pBlock, uint blockSize, HaloWarsMem.BALContext context) { if (mAllocations.Contains(pBlock)) { GlobalErrors.addError(" LineAlloc : Multiple Allocations of block 0x" + pBlock.ToString("x") + " in heap 0x" + pHeap.ToString("x")); return; } BlockAlloc ba = new BlockAlloc(); ba.mpHeap = pHeap; ba.mpBlock = pBlock; ba.mBlockSize = blockSize; context.copyTo(ref ba.mContext); mAllocations.Add(pBlock, ba); mTotalBytes += blockSize; }
//============================================================================== // deleteMem //============================================================================== public void deleteMem(uint pBlock, HaloWarsMem.BALContext context) { mNumDeletes++; FileAlloc fa = getFileContaining(pBlock); mBlockToFile.Remove(pBlock); if (fa != null) { fa.deleteMem(pBlock); if (fa.getTotalAllocatedBytes(false) == 0) { mAllocations.Remove(fa.getFilename()); } return; } GlobalErrors.addError("HeapAlloc : Stray delete of block 0x" + pBlock.ToString("x") + ". No file!"); }
//============================================================================ // ListenForClients //============================================================================ private void ListenForClients() { try { this.tcpListener.Start(); this.tcpListener.Server.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.ReuseAddress, true); //blocks until a client has connected to the server mTCPClient = this.tcpListener.AcceptTcpClient(); } catch (Exception e) { GlobalErrors.addError("SHIT!"); } //create a thread to handle communication with connected client Thread clientThread = new Thread(new ParameterizedThreadStart(HandleClientComm)); clientThread.Start(mTCPClient); }
//========================================= // allocMem //========================================= public void allocMem(uint pHeap, uint pBlock, uint blockSize, uint lineNum, HaloWarsMem.BALContext context) { if (mBlockToLineNum.Contains(pBlock)) { GlobalErrors.addError("FileAlloc : Multiple Allocations of block 0x" + pBlock.ToString("x") + " in heap 0x" + pHeap.ToString("x")); return; } LineAlloc la = (LineAlloc)mAllocations[lineNum]; if (la == null) { la = new LineAlloc(lineNum); mAllocations.Add(lineNum, la); } la.allocMem(pHeap, pBlock, blockSize, context); mBlockToLineNum.Add(pBlock, lineNum); mTotalBytes += blockSize; }
//============================================================================ // processStream //============================================================================ static public void processBinaryStream(BinaryReader pStream, string pdbFilename, uint throttleAmout) { forceOnConnectEvent("127.0.0.1", pdbFilename); byte[] header = new byte[4]; Interlocked.Exchange(ref mIsRunning, 1); mNumBytesWritten = (ulong)pStream.BaseStream.Length; mNumBytesRead = 0; int numPacketsRecieved = 0; while (mIsRunning > 0 && mNumBytesRead < mNumBytesWritten) { if (mIsPaused == 1) { continue; } try { pStream.Read(header, 0, 4); //read the header.. byte packetStart = header[0]; byte packetType = header[1]; int packetSize = (int)Xbox_EndianSwap.endSwapI16(BitConverter.ToUInt16(header, 2)); if (packetStart != HaloWarsMem.cALPacketPrefix) { continue; //ERROR HERE?? } //modify our packet size since we've already read in 4 bytes.. packetSize -= 4; // -= sizeof the data we've already read in.. if (packetSize < 0) { packetSize = 0; } //read in the rest of the packet data byte[] packetData = null; if (packetSize > 0) { //read the packet packetData = new byte[packetSize]; int readSize = pStream.Read(packetData, 0, packetSize); if (readSize != packetSize) { break; //ERROR HERE?? } } recieveProcessPacket(header, packetType, packetSize, ref packetData); numPacketsRecieved++; mNumBytesRead += (ulong)(4 + packetSize); //this is for reading from Disk. We throttle a bit to let the UI catch up.. if (throttleAmout != 0) { for (int i = 0; i < throttleAmout; i++) { ; } //Thread.Sleep((int)throttleAmout); } } catch (Exception e) { GlobalErrors.addError(e.InnerException.ToString()); break; } } forceOnDisconnectEvent(); }
//============================================================================ // processNetworkStream //============================================================================ static public void processNetworkStream(string IPAddy, NetworkStream pStream, string pdbFilename, TcpClient pClient) { forceOnConnectEvent(IPAddy, pdbFilename); Interlocked.Exchange(ref mIsRunning, 1); string cTempNetworkFile = "C:\\_tmpNetworkLog.bin"; if (File.Exists(cTempNetworkFile)) { File.Delete(cTempNetworkFile); } initNetworkReaderThread(cTempNetworkFile, pStream, pClient); FileStream mLoggedFileStreamReader = null; try { mLoggedFileStreamReader = new FileStream(cTempNetworkFile, FileMode.OpenOrCreate, FileAccess.Read, FileShare.ReadWrite); }catch (Exception ex) { GlobalErrors.addError("Error opening temp network stream file : \n" + ex.InnerException.ToString()); Interlocked.Exchange(ref mIsRunning, 0); } BinaryReader br = new BinaryReader(mLoggedFileStreamReader); byte[] header = new byte[4]; mNumBytesRead = 0; while (mIsRunning > 0) { try { if (mIsPaused == 1 || mNumBytesRead >= mNumBytesWritten) { continue; } if (!fillBufferFromStream(br, header, 4, pClient)) { GlobalErrors.addError("Error reading buffer from streams"); break; } byte packetStart = header[0]; byte packetType = header[1]; int packetSize = (int)Xbox_EndianSwap.endSwapI16(BitConverter.ToUInt16(header, 2)); if (packetStart != HaloWarsMem.cALPacketPrefix) { GlobalErrors.addError("Invalid Packet recieved in network stream. Disconnecting.."); break; } //modify our packet size since we've already read in 4 bytes.. packetSize -= 4; // -= sizeof the data we've already read in.. if (packetSize < 0) { packetSize = 0; } //read in the rest of the packet data byte[] packetData = null; if (packetSize > 0) { //read the packet packetData = new byte[packetSize]; if (!fillBufferFromStream(br, packetData, packetSize, pClient)) { GlobalErrors.addError("Error reading buffer from streams"); break; } } recieveProcessPacket(header, packetType, packetSize, ref packetData); int incAmt = 4 + packetSize; mNumBytesRead += (ulong)incAmt; } catch (Exception e) { GlobalErrors.addError(e.InnerException.ToString()); break; } } stopProcessing(); mLoggedFileStreamReader.Close(); br.Close(); forceOnDisconnectEvent(); }