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);
}
