PRStatus nsSOCKSSocketInfo::ReadV5AddrTypeAndLength(uint8_t *type, uint32_t *len) { NS_ABORT_IF_FALSE(mState == SOCKS5_READ_CONNECT_RESPONSE_TOP || mState == SOCKS5_READ_CONNECT_RESPONSE_BOTTOM, "Invalid state!"); NS_ABORT_IF_FALSE(mDataLength >= 5, "SOCKS 5 connection reply must be at least 5 bytes!"); // Seek to the address location mReadOffset = 3; *type = ReadUint8(); switch (*type) { case 0x01: // ipv4 *len = 4 - 1; break; case 0x04: // ipv6 *len = 16 - 1; break; case 0x03: // fqdn *len = ReadUint8(); break; default: // wrong address type LOGERROR(("socks5: wrong address type in connection reply!")); return PR_FAILURE; } return PR_SUCCESS; }
PRStatus nsSOCKSSocketInfo::ReadV5AuthResponse() { NS_ABORT_IF_FALSE(mState == SOCKS5_READ_AUTH_RESPONSE, "Handling SOCKS 5 auth method reply in wrong state!"); NS_ABORT_IF_FALSE(mDataLength == 2, "SOCKS 5 auth method reply must be 2 bytes!"); LOGDEBUG(("socks5: checking auth method reply")); // Check version number if (ReadUint8() != 0x05) { LOGERROR(("socks5: unexpected version in the reply")); HandshakeFinished(PR_CONNECT_REFUSED_ERROR); return PR_FAILURE; } // Make sure our authentication choice was accepted if (ReadUint8() != 0x00) { LOGERROR(("socks5: server did not accept our authentication method")); HandshakeFinished(PR_CONNECT_REFUSED_ERROR); return PR_FAILURE; } return WriteV5ConnectRequest(); }
PRStatus nsSOCKSSocketInfo::ReadV4ConnectResponse() { NS_ABORT_IF_FALSE(mState == SOCKS4_READ_CONNECT_RESPONSE, "Handling SOCKS 4 connection reply in wrong state!"); NS_ABORT_IF_FALSE(mDataLength == 8, "SOCKS 4 connection reply must be 8 bytes!"); LOGDEBUG(("socks4: checking connection reply")); if (ReadUint8() != 0x00) { LOGERROR(("socks4: wrong connection reply")); HandshakeFinished(PR_CONNECT_REFUSED_ERROR); return PR_FAILURE; } // See if our connection request was granted if (ReadUint8() == 90) { LOGDEBUG(("socks4: connection successful!")); HandshakeFinished(); return PR_SUCCESS; } LOGERROR(("socks4: unable to connect")); HandshakeFinished(PR_CONNECT_REFUSED_ERROR); return PR_FAILURE; }
bool WaveReader::DecodeAudioData() { MOZ_ASSERT(OnTaskQueue()); int64_t pos = GetPosition() - mWavePCMOffset; int64_t len = GetDataLength(); int64_t remaining = len - pos; NS_ASSERTION(remaining >= 0, "Current wave position is greater than wave file length"); static const int64_t BLOCK_SIZE = 4096; int64_t readSize = std::min(BLOCK_SIZE, remaining); int64_t frames = readSize / mFrameSize; static_assert(uint64_t(BLOCK_SIZE) < UINT_MAX / sizeof(AudioDataValue) / MAX_CHANNELS, "bufferSize calculation could overflow."); const size_t bufferSize = static_cast<size_t>(frames * mChannels); nsAutoArrayPtr<AudioDataValue> sampleBuffer(new AudioDataValue[bufferSize]); static_assert(uint64_t(BLOCK_SIZE) < UINT_MAX / sizeof(char), "BLOCK_SIZE too large for enumerator."); nsAutoArrayPtr<char> dataBuffer(new char[static_cast<size_t>(readSize)]); if (!ReadAll(dataBuffer, readSize)) { return false; } // convert data to samples const char* d = dataBuffer.get(); AudioDataValue* s = sampleBuffer.get(); for (int i = 0; i < frames; ++i) { for (unsigned int j = 0; j < mChannels; ++j) { if (mSampleFormat == FORMAT_U8) { uint8_t v = ReadUint8(&d); *s++ = UnsignedByteToAudioSample<AudioDataValue>(v); } else if (mSampleFormat == FORMAT_S16) { int16_t v = ReadInt16LE(&d); *s++ = SignedShortToAudioSample<AudioDataValue>(v); } } } double posTime = BytesToTime(pos); double readSizeTime = BytesToTime(readSize); NS_ASSERTION(posTime <= INT64_MAX / USECS_PER_S, "posTime overflow"); NS_ASSERTION(readSizeTime <= INT64_MAX / USECS_PER_S, "readSizeTime overflow"); NS_ASSERTION(frames < INT32_MAX, "frames overflow"); mAudioQueue.Push(new AudioData(pos, static_cast<int64_t>(posTime * USECS_PER_S), static_cast<int64_t>(readSizeTime * USECS_PER_S), static_cast<int32_t>(frames), sampleBuffer.forget(), mChannels, mSampleRate)); return true; }
otError SpinelDecoder::ReadInt8(int8_t &aInt8) { otError error = OT_ERROR_NONE; uint8_t byte; SuccessOrExit(error = ReadUint8(byte)); aInt8 = static_cast<int8_t>(byte); exit: return error; }
otError SpinelDecoder::ReadBool(bool &aBool) { otError error = OT_ERROR_NONE; uint8_t byte; SuccessOrExit(error = ReadUint8(byte)); // Boolean value are encoded in 8-bits as either 0x00 or 0x01. All other values are illegal. if (byte == 0x00) { aBool = false; } else if (byte == 0x01) { aBool = true; } else { error = OT_ERROR_PARSE; } exit: return error; }
size_t CObjectIStreamJson::ReadCustomBytes( ByteBlock& block, char* dst, size_t length) { if (m_BinaryFormat == eString_Base64) { return ReadBase64Bytes(block, dst, length); } else if (m_BinaryFormat == eString_Hex) { return ReadHexBytes(block, dst, length); } bool end_of_data = false; size_t count = 0; while ( !end_of_data && length-- > 0 ) { Uint1 c = 0; Uint1 mask=0x80; switch (m_BinaryFormat) { case eArray_Bool: for (; !end_of_data && mask!=0; mask >>= 1) { if (ReadBool()) { c |= mask; } end_of_data = !GetChar(',', true); } ++count; *dst++ = c; break; case eArray_01: for (; !end_of_data && mask!=0; mask >>= 1) { if (ReadChar() != '0') { c |= mask; } end_of_data = !GetChar(',', true); } ++count; *dst++ = c; break; default: case eArray_Uint: c = (Uint1)ReadUint8(); end_of_data = !GetChar(',', true); ++count; *dst++ = c; break; case eString_01: case eString_01B: for (; !end_of_data && mask!=0; mask >>= 1) { char t = GetChar(); end_of_data = t == '\"' || t == 'B'; if (!end_of_data && t != '0') { c |= mask; } if (t == '\"') { m_Input.UngetChar(t); } } if (mask != 0x40) { ++count; *dst++ = c; } break; } } if (end_of_data) { block.EndOfBlock(); } return count; }
PRStatus nsSOCKSSocketInfo::ReadV5ConnectResponseTop() { uint8_t res; uint32_t len; NS_ABORT_IF_FALSE(mState == SOCKS5_READ_CONNECT_RESPONSE_TOP, "Invalid state!"); NS_ABORT_IF_FALSE(mDataLength == 5, "SOCKS 5 connection reply must be exactly 5 bytes!"); LOGDEBUG(("socks5: checking connection reply")); // Check version number if (ReadUint8() != 0x05) { LOGERROR(("socks5: unexpected version in the reply")); HandshakeFinished(PR_CONNECT_REFUSED_ERROR); return PR_FAILURE; } // Check response res = ReadUint8(); if (res != 0x00) { PRErrorCode c = PR_CONNECT_REFUSED_ERROR; switch (res) { case 0x01: LOGERROR(("socks5: connect failed: " "01, General SOCKS server failure.")); break; case 0x02: LOGERROR(("socks5: connect failed: " "02, Connection not allowed by ruleset.")); break; case 0x03: LOGERROR(("socks5: connect failed: 03, Network unreachable.")); c = PR_NETWORK_UNREACHABLE_ERROR; break; case 0x04: LOGERROR(("socks5: connect failed: 04, Host unreachable.")); break; case 0x05: LOGERROR(("socks5: connect failed: 05, Connection refused.")); break; case 0x06: LOGERROR(("socks5: connect failed: 06, TTL expired.")); c = PR_CONNECT_TIMEOUT_ERROR; break; case 0x07: LOGERROR(("socks5: connect failed: " "07, Command not supported.")); break; case 0x08: LOGERROR(("socks5: connect failed: " "08, Address type not supported.")); c = PR_BAD_ADDRESS_ERROR; break; default: LOGERROR(("socks5: connect failed.")); break; } HandshakeFinished(c); return PR_FAILURE; } if (ReadV5AddrTypeAndLength(&res, &len) != PR_SUCCESS) { HandshakeFinished(PR_BAD_ADDRESS_ERROR); return PR_FAILURE; } mState = SOCKS5_READ_CONNECT_RESPONSE_BOTTOM; WantRead(len + 2); return PR_SUCCESS; }
//============================================================ // <T>从输入流反序列化数据内容。</T> // // @param pInput 输入流 //============================================================ TResult FUiControl::OnUnserialize(IDataInput* pInput){ MO_CHECK(pInput, return ENull); // 读取属性 _flags = pInput->ReadInt32(); _name.Unserialize(pInput); _label.UnserializeAutomatic(pInput); // 读取位置 _optionEnable = TestFlag(EControlFlag_Enable); _optionVisible = TestFlag(EControlFlag_Visible); _dockCd = (EControlDock)pInput->ReadUint8(); _location.x = pInput->ReadInt16(); _location.y = pInput->ReadInt16(); _size.width = pInput->ReadUint16(); _size.height = pInput->ReadUint16(); // 读取边距 if(TestFlag(EControlFlag_Margin)){ _margin.Unserialize8(pInput); } if(TestFlag(EControlFlag_Padding)){ _padding.Unserialize8(pInput); } // 读取边框 if(TestFlag(EControlFlag_BorderOuter)){ _borderOuter.Unserialize(pInput); }