// For Ptp sockets, data in read as a byte stream. Data is not organized in packets. // Read as much data as the provided buffer can contain. public virtual int recv(TPointer data, TPointer32 dataLengthAddr, int timeout, int nonblock) { int result = 0; try { SceKernelThreadInfo thread = Modules.ThreadManForUserModule.CurrentThread; if (pollRecv(data, dataLengthAddr, thread)) { // Recv completed immediately result = thread.cpuContext._v0; } else if (nonblock != 0) { // Recv cannot be completed in non-blocking mode result = SceKernelErrors.ERROR_NET_ADHOC_NO_DATA_AVAILABLE; } else { // Block current thread BlockedPdpAction blockedPdpAction = new BlockedPtpRecv(this, data, dataLengthAddr, timeout); blockedPdpAction.blockCurrentThread(); } } catch (IOException e) { result = SceKernelErrors.ERROR_NET_ADHOC_DISCONNECTED; Console.WriteLine("recv", e); } return(result); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: protected bool pollRecv(pspsharp.HLE.TPointer data, pspsharp.HLE.TPointer32 dataLengthAddr, pspsharp.HLE.kernel.types.SceKernelThreadInfo thread) throws java.io.IOException protected internal virtual bool pollRecv(TPointer data, TPointer32 dataLengthAddr, SceKernelThreadInfo thread) { int Length = dataLengthAddr.getValue(); bool completed = false; if (Length > 0) { if (RcvdData <= 0 || receivedMessage != null) { update(); } if (RcvdData > 0) { if (Length > RcvdData) { Length = RcvdData; } // Copy the data already received dataLengthAddr.setValue(Length); Memory mem = Memory.Instance; mem.memcpy(data.Address, buffer.addr, Length); if (RcvdData > Length) { // Shift the remaining buffer data to the beginning of the buffer mem.memmove(buffer.addr, buffer.addr + Length, RcvdData - Length); } rcvdData -= Length; //if (log.DebugEnabled) { Console.WriteLine(string.Format("Returned received data: {0:D} bytes", Length)); if (log.TraceEnabled) { log.trace(string.Format("Returned data: {0}", Utilities.getMemoryDump(data.Address, Length))); } } setReturnValue(thread, 0); completed = true; } } return(completed); }
private void startCommandWithPageAddress() { needPageAddress = false; switch (command) { case PSP_NAND_COMMAND_READ_ID: if (pageAddress == 0) { // This ID will configure: // - sceNandGetPageSize returning 0x200 // - sceNandGetPagesPerBlock returning 0x20 // - sceNandGetTotalBlocks returning 0x800 data[0] = 0xEC; // Manufacturer's code (SAMSUNG) data[1] = 0x75; // Device code (K9F5608U0C) } break; case PSP_NAND_COMMAND_READ_EXTRA: TPointer spare = dataMemory.Pointer; sceNandModule.hleNandReadPages(pageAddress >> 10, TPointer.NULL, spare, 1, true, true, true); break; } }
/// <summary> /// Creates a MemoryReader to read values from memory. /// </summary> /// <param name="address"> the address and memory where to start reading. </param> /// <param name="Length"> the maximum number of bytes that can be read. </param> /// <param name="step"> when step == 1, read 8-bit values /// when step == 2, read 16-bit values /// when step == 4, read 32-bit values /// other value for step are not allowed. </param> /// <returns> the MemoryReader </returns> public static IMemoryReader getMemoryReader(TPointer address, int Length, int step) { return(getMemoryReader(address.Memory, address.Address, Length, step)); }
private void startDma(int dmaControl) { this.dmaControl = dmaControl; if ((dmaControl & DMA_CONTROL_START) != 0) { int ppn = dmaAddress >> 10; int scramble = getScramble(ppn); // Read or write operation? if ((dmaControl & DMA_CONTROL_WRITE) != 0) { int lbn = endianSwap16(pageEccMemory.read16(6) & 0xFFFF); if (lbn == 0xFFFF) { //if (log.DebugEnabled) { Console.WriteLine(string.Format("writing to ppn=0x{0:X} with lbn=0x{1:X} ignored", ppn, lbn)); } } else { TPointer spare = pageEccMemory.Pointer; sceNandModule.hleNandWriteSparePages(ppn, spare, 1, true, true, true); TPointer user = pageDataMemory.Pointer; // Updating the scramble as the LBN corresponding to the PPN might have been moved scramble = getScramble(ppn); if (scramble != 0) { sceNand.descramblePage(scramble, ppn, MMIOHandlerNandPage.Instance.Data, scrambleBuffer); user = scrambleBufferMemory.Pointer; } sceNandModule.hleNandWriteUserPages(ppn, user, 1, true, true); //if (log.DebugEnabled) { sbyte[] userBytes = new sbyte[sceNand.pageSize]; user = scramble != 0 ? scrambleBufferMemory.Pointer : pageDataMemory.Pointer; for (int i = 0; i < userBytes.Length; i++) { userBytes[i] = user.getValue8(i); } sbyte[] spareBytes = new sbyte[16]; spare = pageEccMemory.Pointer; for (int i = 0; i < spareBytes.Length; i++) { spareBytes[i] = spare.getValue8(i); } Console.WriteLine(string.Format("hleNandWritePages ppn=0x{0:X}, lbn=0x{1:X}, scramble=0x{2:X}: {3}{4}Spare: {5}", ppn, lbn, scramble, Utilities.getMemoryDump(userBytes), lineSeparator, Utilities.getMemoryDump(spareBytes))); } } triggerInterrupt(PSP_NAND_INTR_WRITE_COMPLETED); } else { TPointer user = scramble != 0 ? scrambleBufferMemory.Pointer : pageDataMemory.Pointer; TPointer spare = pageEccMemory.Pointer; sceNandModule.hleNandReadPages(ppn, user, spare, 1, true, true, true); //if (log.DebugEnabled) { sbyte[] bytes = new sbyte[sceNand.pageSize]; user = scramble != 0 ? scrambleBufferMemory.Pointer : pageDataMemory.Pointer; for (int i = 0; i < bytes.Length; i++) { bytes[i] = user.getValue8(i); } Console.WriteLine(string.Format("hleNandReadPages ppn=0x{0:X}, scramble=0x{1:X}: {2}", ppn, scramble, Utilities.getMemoryDump(bytes))); } if (scramble != 0) { sceNand.scramblePage(scramble, ppn, scrambleBuffer, MMIOHandlerNandPage.Instance.Data); } triggerInterrupt(PSP_NAND_INTR_READ_COMPLETED); } } }
private int hleUtilsBufferCopyWithRange() { TPointer outAddr = new TPointer(Memory, normalizeAddress(destAddr)); TPointer inAddr = new TPointer(Memory, normalizeAddress(sourceAddr)); int inSize; int outSize; int dataSize; int dataOffset; switch (command) { case PSP_KIRK_CMD_ENCRYPT: case PSP_KIRK_CMD_ENCRYPT_FUSE: // AES128_CBC_Header dataSize = inAddr.getValue32(16); inSize = dataSize + 20; outSize = dataSize + 20; break; case PSP_KIRK_CMD_DECRYPT: case PSP_KIRK_CMD_DECRYPT_FUSE: // AES128_CBC_Header dataSize = inAddr.getValue32(16); inSize = dataSize + 20; outSize = dataSize; break; case PSP_KIRK_CMD_DECRYPT_PRIVATE: // AES128_CMAC_Header dataSize = inAddr.getValue32(112); dataOffset = inAddr.getValue32(116); inSize = 144 + Utilities.alignUp(dataSize, 15) + dataOffset; outSize = Utilities.alignUp(dataSize, 15); break; case PSP_KIRK_CMD_PRIV_SIG_CHECK: // AES128_CMAC_Header dataSize = inAddr.getValue32(112); dataOffset = inAddr.getValue32(116); inSize = 144 + Utilities.alignUp(dataSize, 15) + dataOffset; outSize = 0; break; case PSP_KIRK_CMD_SHA1_HASH: // SHA1_Header inSize = inAddr.getValue32(0) + 4; outSize = 20; break; case PSP_KIRK_CMD_ECDSA_GEN_KEYS: inSize = 0; outSize = 0x3C; break; case PSP_KIRK_CMD_ECDSA_MULTIPLY_POINT: inSize = 0x3C; outSize = 0x28; break; case PSP_KIRK_CMD_PRNG: inSize = 0; outSize = 0x10; // TODO Unknown outSize? break; case PSP_KIRK_CMD_ECDSA_SIGN: inSize = 0x34; outSize = 0x28; break; case PSP_KIRK_CMD_ECDSA_VERIFY: inSize = 0x64; outSize = 0; break; case PSP_KIRK_CMD_INIT: inSize = 0; outSize = 0; break; case PSP_KIRK_CMD_CERT_VERIFY: inSize = 0xB8; outSize = 0; break; default: Console.WriteLine(string.Format("MMIOHandlerKirk.hleUtilsBufferCopyWithRange unimplemented KIRK command 0x{0:X}", command)); result = PSP_KIRK_INVALID_OPERATION; return(0); } //if (log.DebugEnabled) { Console.WriteLine(string.Format("hleUtilsBufferCopyWithRange input: {0}", Utilities.getMemoryDump(inAddr, inSize))); } foreach (int commandToBeDumped in commandsToBeDumped) { if (command == commandToBeDumped) { string dumpFileName = string.Format("dump.hleUtilsBufferCopyWithRange.{0:D}", dumpIndex++); Console.WriteLine(string.Format("MMIOHandlerKirk: hleUtilsBufferCopyWithRange dumping command=0x{0:X}, outputSize=0x{1:X}, inputSize=0x{2:X}, input dumped into file '{3}'", command, outSize, inSize, dumpFileName)); try { System.IO.Stream dump = new System.IO.FileStream(dumpFileName, System.IO.FileMode.Create, System.IO.FileAccess.Write); sbyte[] inputBuffer = new sbyte[inSize]; for (int i = 0; i < inSize; i++) { inputBuffer[i] = inAddr.getValue8(i); } dump.Write(inputBuffer, 0, inputBuffer.Length); dump.Close(); } catch (IOException) { } } } result = Modules.semaphoreModule.hleUtilsBufferCopyWithRange(outAddr, outSize, inAddr, inSize, command); //if (log.DebugEnabled) { Console.WriteLine(string.Format("hleUtilsBufferCopyWithRange result=0x{0:X}, output: {1}", result, Utilities.getMemoryDump(outAddr, outSize))); } if (result != 0) { string dumpFileName = string.Format("dump.hleUtilsBufferCopyWithRange.{0:D}", dumpIndex++); Console.WriteLine(string.Format("MMIOHandlerKirk: hleUtilsBufferCopyWithRange returned error result=0x{0:X} for command=0x{1:X}, outputSize=0x{2:X}, inputSize=0x{3:X}, input dumped into file '{4}'", result, command, outSize, inSize, dumpFileName)); try { System.IO.Stream dump = new System.IO.FileStream(dumpFileName, System.IO.FileMode.Create, System.IO.FileAccess.Write); sbyte[] inputBuffer = new sbyte[inSize]; for (int i = 0; i < inSize; i++) { inputBuffer[i] = inAddr.getValue8(i); } dump.Write(inputBuffer, 0, inputBuffer.Length); dump.Close(); } catch (IOException) { } } return(System.Math.Max(inSize, outSize)); }
public override int ioRead(TPointer outputPointer, int outputLength) { return(doRead(outputPointer, null, 0, outputLength)); }
private int doRead(TPointer outputPointer, sbyte[] outputBuffer, int outputOffset, int outputLength) { if (EOF) { return(-1); } int readLength = 0; int readAddr = outputPointer != null ? outputPointer.Address : 0; while (remainingPacketLength > 0 && readLength < outputLength) { int maxReadLength = System.Math.Min(remainingPacketLength, outputLength - readLength); int l; if (outputBuffer != null) { l = vFile.ioRead(outputBuffer, outputOffset, maxReadLength); } else if (outputPointer != null) { l = vFile.ioRead(new TPointer(outputPointer.Memory, readAddr), maxReadLength); } else { l = maxReadLength; } if (l > 0) { remainingPacketLength -= l; readLength += l; readAddr += l; outputOffset += l; position += l; } else if (l < 0) { break; } } if (remainingPacketLength > 0) { return(readLength); } while (!EOF && readLength < outputLength) { long startIndex = vFile.Position; int startCode = 0xFF; while ((startCode & PACKET_START_CODE_MASK) != PACKET_START_CODE_PREFIX && !EOF) { startCode = (startCode << 8) | read8(); } //if (log.DebugEnabled) { Console.WriteLine(string.Format("StartCode 0x{0:X8}, offset {1:X8}, skipped {2:D}", startCode, vFile.Position, vFile.Position - startIndex - 4)); } switch (startCode) { case PACK_START_CODE: { skip(10); break; } case SYSTEM_HEADER_START_CODE: { skip(14); break; } case PADDING_STREAM: case PRIVATE_STREAM_2: { int Length = read16(); skip(Length); break; } case PRIVATE_STREAM_1: { // Audio stream int Length = read16(); PesHeader pesHeader = new PesHeader(audioChannel); Length = readPesHeader(pesHeader, Length, startCode); if (pesHeader.Channel == audioChannel || audioChannel < 0) { int packetLength = 0; while (packetLength < Length && readLength < outputLength) { int maxReadLength = System.Math.Min(Length - packetLength, outputLength - readLength); int l; if (outputBuffer != null) { l = vFile.ioRead(outputBuffer, outputOffset, maxReadLength); } else if (outputPointer != null) { l = vFile.ioRead(new TPointer(outputPointer.Memory, readAddr), maxReadLength); } else { l = maxReadLength; } if (l > 0) { readLength += l; readAddr += l; outputOffset += l; packetLength += l; position += l; } else if (l < 0) { break; } } remainingPacketLength = Length - packetLength; } else { skip(Length); } break; } case 0x1E0: case 0x1E1: case 0x1E2: case 0x1E3: case 0x1E4: case 0x1E5: case 0x1E6: case 0x1E7: case 0x1E8: case 0x1E9: case 0x1EA: case 0x1EB: case 0x1EC: case 0x1ED: case 0x1EE: case 0x1EF: { // Video Stream, skipped int Length = read16(); skip(Length); break; } default: { Console.WriteLine(string.Format("Unknown StartCode 0x{0:X8}, offset {1:X8}", startCode, vFile.Position)); } break; } } return(readLength); }
protected internal BlockedPtpRecv(PtpObject ptpObject, TPointer data, TPointer32 dataLengthAddr, int timeout) : base(ptpObject, timeout) { this.data = data; this.dataLengthAddr = dataLengthAddr; }
public override int ioRead(TPointer outputPointer, int outputLength) { return(base.ioRead(outputPointer, outputLength)); }