static void H(const AString &s, AString *out) {
    out->clear();

    MD5_CTX m;
    MD5_Init(&m);
    MD5_Update(&m, s.c_str(), s.size());

    uint8_t key[16];
    MD5_Final(key, &m);

    for (size_t i = 0; i < 16; ++i) {
        char nibble = key[i] >> 4;
        if (nibble <= 9) {
            nibble += '0';
        } else {
            nibble += 'a' - 10;
        }
        out->append(&nibble, 1);

        nibble = key[i] & 0x0f;
        if (nibble <= 9) {
            nibble += '0';
        } else {
            nibble += 'a' - 10;
        }
        out->append(&nibble, 1);
    }
}
示例#2
0
bool cScoreboardSerializer::Save(void)
{
	cFastNBTWriter Writer;

	SaveScoreboardToNBT(Writer);

	Writer.Finish();
	
	#ifdef _DEBUG
	cParsedNBT TestParse(Writer.GetResult().data(), Writer.GetResult().size());
	ASSERT(TestParse.IsValid());
	#endif  // _DEBUG

	cFile File;
	if (!File.Open(FILE_IO_PREFIX + m_Path, cFile::fmWrite))
	{
		return false;
	}

	AString Compressed;
	int res = CompressStringGZIP(Writer.GetResult().data(), Writer.GetResult().size(), Compressed);

	if (res != Z_OK)
	{
		return false;
	}

	File.Write(Compressed.data(), Compressed.size());
	File.Close();

	return true;
}
	Bool HawkProfiler::Start(const AString& sAddr)
	{
		if (!m_bRunning)
		{
			if (sAddr.size())
				m_sAddr = sAddr;

			GetProcessorNumber();
			GetTotalMem();
			GetCpuUsage();
			GetMemUsage();

			if(!m_sSocket.Create(AF_INET,SOCK_DGRAM,IPPROTO_UDP)) 
			{
				HawkPrint("Profiler Init Socket Error.");
				return false;
			}

			m_sSocket.SetNoDelay(true);
			m_sSocket.SetBlocking(false);

			if(!m_sSocket.Bind(SocketAddr(m_sAddr)))
			{
				HawkPrint("Profiler Bind Socket Error.");
				return false;
			}

			m_bRunning = true;
			m_pThread  = new HawkThread(hawk_ProfilerRoutine);
			m_pThread->Start(this);

			return true;
		}		
		return false;
	}
示例#4
0
	Bool HsGateway::TrustSession(void* pSession, OctetsStream* pIBuffer)
	{
		if (pSession && pIBuffer)
		{
			//QQ平台网关校验信息过滤
			if (m_iPlatform == 1)
			{
				if (pIBuffer->AvailableSize() >= TGW_BUFFER_SIZE)
				{
					AString sTgw = (Char*)pIBuffer->AvailableData();

#ifdef _DEBUG
					HawkFmtPrint("TGW: %s", sTgw.c_str());
#endif

					Bool bStart = HawkStringUtil::BeginWith<AString>(sTgw, "tgw_l7_forward");
					Bool bEnd   = HawkStringUtil::EndWith<AString>(sTgw, "\r\n\r\n");

					if (bStart && bEnd)
					{
						UInt32 iCrc  = HawkOSOperator::CalcCrc((const UChar*)sTgw.c_str(),(UInt32)sTgw.size());
						UInt32* pCrc = (UInt32*)((Char*)pIBuffer->AvailableData() + (TGW_BUFFER_SIZE - sizeof(UInt32)));
						if (pCrc && iCrc == *pCrc)
						{
							pIBuffer->MoveNonius(TGW_BUFFER_SIZE);
							return true;
						}
					}
				}
				return false;
			}
		}
		return true;
	}
bool cSchematicFileSerializer::LoadFromSchematicFile(cBlockArea & a_BlockArea, const AString & a_FileName)
{
	// Un-GZip the contents:
	AString Contents;
	cGZipFile File;
	if (!File.Open(a_FileName, cGZipFile::fmRead))
	{
		LOG("Cannot open the schematic file \"%s\".", a_FileName.c_str());
		return false;
	}
	int NumBytesRead = File.ReadRestOfFile(Contents);
	if (NumBytesRead < 0)
	{
		LOG("Cannot read GZipped data in the schematic file \"%s\", error %d", a_FileName.c_str(), NumBytesRead);
		return false;
	}
	File.Close();

	// Parse the NBT:
	cParsedNBT NBT(Contents.data(), Contents.size());
	if (!NBT.IsValid())
	{
		LOG("Cannot parse the NBT in the schematic file \"%s\".", a_FileName.c_str());
		return false;
	}

	return LoadFromSchematicNBT(a_BlockArea, NBT);
}
status_t WifiDisplaySource::sendM16(int32_t sessionID) {
    AString request = "GET_PARAMETER rtsp://localhost/wfd1.0 RTSP/1.0\r\n";
    AppendCommonResponse(&request, mNextCSeq);

    CHECK_EQ(sessionID, mClientSessionID);
    request.append(
            StringPrintf("Session: %d\r\n", mClientInfo.mPlaybackSessionID));
    request.append("\r\n");  // Empty body

    status_t err =
        mNetSession->sendRequest(sessionID, request.c_str(), request.size());

    if (err != OK) {
        return err;
    }

    registerResponseHandler(
            sessionID, mNextCSeq, &WifiDisplaySource::onReceiveM16Response);

    ++mNextCSeq;

    scheduleKeepAlive(sessionID);

    return OK;
}
示例#7
0
void cProtocolRecognizer::DataReceived(const char * a_Data, int a_Size)
{
	if (m_Protocol == NULL)
	{
		if (!m_Buffer.Write(a_Data, a_Size))
		{
			m_Client->Kick("Unsupported protocol version");
			return;
		}
		
		if (!TryRecognizeProtocol())
		{
			return;
		}

		// The protocol has just been recognized, dump the whole m_Buffer contents into it for parsing:
		AString Dump;
		m_Buffer.ResetRead();
		m_Buffer.ReadAll(Dump);
		m_Protocol->DataReceived(Dump.data(), Dump.size());
	}
	else
	{
		m_Protocol->DataReceived(a_Data, a_Size);
	}
}
示例#8
0
bool cPrefabPiecePool::LoadFromString(const AString & a_Contents, const AString & a_FileName, bool a_LogWarnings)
{
	// If the contents start with GZip signature, ungzip and retry:
	if (a_Contents.substr(0, 3) == "\x1f\x8b\x08")
	{
		AString Uncompressed;
		auto res = UncompressStringGZIP(a_Contents.data(), a_Contents.size(), Uncompressed);
		if (res == Z_OK)
		{
			return LoadFromString(Uncompressed, a_FileName, a_LogWarnings);
		}
		else
		{
			CONDWARNING(a_LogWarnings, "Failed to decompress Gzip data in file %s: %d", a_FileName.c_str(), res);
			return false;
		}
	}

	// Search the first 8 KiB of the file for the format auto-detection string:
	auto Header = a_Contents.substr(0, 8192);
	if (Header.find("CubesetFormatVersion =") != AString::npos)
	{
		return LoadFromCubeset(a_Contents, a_FileName, a_LogWarnings);
	}
	CONDWARNING(a_LogWarnings, "Cannot load prefabs from file %s, unknown file format", a_FileName.c_str());
	return false;
}
示例#9
0
void cLuaState::Push(const AString & a_String)
{
	ASSERT(IsValid());

	lua_pushlstring(m_LuaState, a_String.data(), a_String.size());
	m_NumCurrentFunctionArgs += 1;
}
示例#10
0
bool cHTTPServer::Initialize(const AString & a_PortsIPv4, const AString & a_PortsIPv6)
{
	// Read the HTTPS cert + key:
	AString CertFile = cFile::ReadWholeFile("webadmin/httpscert.crt");
	AString KeyFile  = cFile::ReadWholeFile("webadmin/httpskey.pem");
	if (!CertFile.empty() && !KeyFile.empty())
	{
		m_Cert.reset(new cX509Cert);
		int res = m_Cert->Parse(CertFile.data(), CertFile.size());
		if (res == 0)
		{
			m_CertPrivKey.reset(new cCryptoKey);
			int res2 = m_CertPrivKey->ParsePrivate(KeyFile.data(), KeyFile.size(), "");
			if (res2 != 0)
			{
				// Reading the private key failed, reset the cert:
				LOGWARNING("WebServer: Cannot read HTTPS certificate private key: -0x%x", -res2);
				m_Cert.reset();
			}
		}
		else
		{
			LOGWARNING("WebServer: Cannot read HTTPS certificate: -0x%x", -res);
		}
	}

	// Notify the admin about the HTTPS / HTTP status
	if (m_Cert.get() == NULL)
	{
		LOGWARNING("WebServer: The server is running in unsecure HTTP mode.");
	}
	else
	{
		LOGINFO("WebServer: The server is running in secure HTTPS mode.");
	}
	
	// Open up requested ports:
	bool HasAnyPort;
	HasAnyPort = m_ListenThreadIPv4.Initialize(a_PortsIPv4);
	HasAnyPort = m_ListenThreadIPv6.Initialize(a_PortsIPv6) || HasAnyPort;
	if (!HasAnyPort)
	{
		return false;
	}
	
	return true;
}
示例#11
0
AString cLuaTCPLink::StartTLSServer(
	const AString & a_OwnCertData,
	const AString & a_OwnPrivKeyData,
	const AString & a_OwnPrivKeyPassword,
	const AString & a_StartTLSData
)
{
	// Check preconditions:
	if (m_SslContext != nullptr)
	{
		return "TLS is already active on this link";
	}
	if (a_OwnCertData.empty()  || a_OwnPrivKeyData.empty())
	{
		return "Provide the server certificate and private key";
	}

	// Create the SSL context:
	m_SslContext.reset(new cLinkSslContext(*this));
	m_SslContext->Initialize(false);

	// Create the peer cert:
	auto OwnCert = std::make_shared<cX509Cert>();
	int res = OwnCert->Parse(a_OwnCertData.data(), a_OwnCertData.size());
	if (res != 0)
	{
		m_SslContext.reset();
		return Printf("Cannot parse server certificate: -0x%x", res);
	}
	auto OwnPrivKey = std::make_shared<cCryptoKey>();
	res = OwnPrivKey->ParsePrivate(a_OwnPrivKeyData.data(), a_OwnPrivKeyData.size(), a_OwnPrivKeyPassword);
	if (res != 0)
	{
		m_SslContext.reset();
		return Printf("Cannot parse server private key: -0x%x", res);
	}
	m_SslContext->SetOwnCert(OwnCert, OwnPrivKey);
	m_SslContext->SetSelf(cLinkSslContextWPtr(m_SslContext));

	// Push the initial data:
	m_SslContext->StoreReceivedData(a_StartTLSData.data(), a_StartTLSData.size());

	// Start the handshake:
	m_SslContext->Handshake();
	return "";
}
示例#12
0
cFastNBTWriter::cFastNBTWriter(const AString & a_RootTagName) :
	m_CurrentStack(0)
{
	m_Stack[0].m_Type = TAG_Compound;
	m_Result.reserve(100 * 1024);
	m_Result.push_back(TAG_Compound);
	WriteString(a_RootTagName.data(), a_RootTagName.size());
}
示例#13
0
status_t WifiDisplaySource::sendTrigger(
        int32_t sessionID, TriggerType triggerType) {
    AString body = "wfd_trigger_method: ";
    switch (triggerType) {
        case TRIGGER_SETUP:
            body.append("SETUP");
            break;
        case TRIGGER_TEARDOWN:
            ALOGI("Sending TEARDOWN trigger.");
            body.append("TEARDOWN");
            break;
        case TRIGGER_PAUSE:
            body.append("PAUSE");
            break;
        case TRIGGER_PLAY:
            body.append("PLAY");
            break;
        default:
            TRESPASS();
    }

    body.append("\r\n");

    AString request = "SET_PARAMETER rtsp://localhost/wfd1.0 RTSP/1.0\r\n";
    AppendCommonResponse(&request, mNextCSeq);

    request.append("Content-Type: text/parameters\r\n");
    request.append(AStringPrintf("Content-Length: %d\r\n", body.size()));
    request.append("\r\n");
    request.append(body);

    status_t err =
        mNetSession->sendRequest(sessionID, request.c_str(), request.size());

    if (err != OK) {
        return err;
    }

    registerResponseHandler(
            sessionID, mNextCSeq, &WifiDisplaySource::onReceiveM5Response);

    ++mNextCSeq;

    return OK;
}
bool splitString(const AString &s, const AString &delimiter, AString *s1, AString *s2) {
    ssize_t pos = s.find(delimiter.c_str());
    if (pos < 0) {
        return false;
    }
    *s1 = AString(s, 0, pos);
    *s2 = AString(s, pos + 1, s.size() - pos - 1);
    return true;
}
示例#15
0
void cProtocol125::SendEntityMetadata(const cEntity & a_Entity)
{
	cCSLock Lock(m_CSPacket);
	WriteByte(PACKET_METADATA);
	WriteInt (a_Entity.GetUniqueID());
	AString MetaData = GetEntityMetaData(a_Entity);
	SendData(MetaData.data(), MetaData.size());
	Flush();
}
示例#16
0
void cProtocol132::HandleEncryptionKeyResponse(const AString & a_EncKey, const AString & a_EncNonce)
{
	// Decrypt EncNonce using privkey
	RSAES<PKCS1v15>::Decryptor rsaDecryptor(cRoot::Get()->GetServer()->GetPrivateKey());
	time_t CurTime = time(NULL);
	CryptoPP::RandomPool rng;
	rng.Put((const byte *)&CurTime, sizeof(CurTime));
	byte DecryptedNonce[MAX_ENC_LEN];
	DecodingResult res = rsaDecryptor.Decrypt(rng, (const byte *)a_EncNonce.data(), a_EncNonce.size(), DecryptedNonce);
	if (!res.isValidCoding || (res.messageLength != 4))
	{
		LOGD("Bad nonce length");
		m_Client->Kick("Hacked client");
		return;
	}
	if (ntohl(*((int *)DecryptedNonce)) != (unsigned)(uintptr_t)this)
	{
		LOGD("Bad nonce value");
		m_Client->Kick("Hacked client");
		return;
	}
	
	// Decrypt the symmetric encryption key using privkey:
	byte DecryptedKey[MAX_ENC_LEN];
	res = rsaDecryptor.Decrypt(rng, (const byte *)a_EncKey.data(), a_EncKey.size(), DecryptedKey);
	if (!res.isValidCoding || (res.messageLength != 16))
	{
		LOGD("Bad key length");
		m_Client->Kick("Hacked client");
		return;
	}
	
	{
		// Send encryption key response:
		cCSLock Lock(m_CSPacket);
		WriteByte((char)0xfc);
		WriteShort(0);
		WriteShort(0);
		Flush();
	}
	
	StartEncryption(DecryptedKey);
	return;
}
// static
status_t M3UParser::parseByteRange(
        const AString &line, uint64_t curOffset,
        uint64_t *length, uint64_t *offset) {
    ssize_t colonPos = line.find(":");

    if (colonPos < 0) {
        return ERROR_MALFORMED;
    }

    ssize_t atPos = line.find("@", colonPos + 1);

    AString lenStr;
    if (atPos < 0) {
        lenStr = AString(line, colonPos + 1, line.size() - colonPos - 1);
    } else {
        lenStr = AString(line, colonPos + 1, atPos - colonPos - 1);
    }

    lenStr.trim();

    const char *s = lenStr.c_str();
    char *end;
    *length = strtoull(s, &end, 10);

    if (s == end || *end != '\0') {
        return ERROR_MALFORMED;
    }

    if (atPos >= 0) {
        AString offStr = AString(line, atPos + 1, line.size() - atPos - 1);
        offStr.trim();

        const char *s = offStr.c_str();
        *offset = strtoull(s, &end, 10);

        if (s == end || *end != '\0') {
            return ERROR_MALFORMED;
        }
    } else {
        *offset = curOffset;
    }

    return OK;
}
示例#18
0
		Air::U1 Converter::SplitFilePath( const AString& str, AString* strPath /*= NULL*/, AString* strFileName /*= NULL*/, AString* strExe /*= NULL*/ )
		{
			if(str.empty())
				return	false;
			U32	uiStrSize	=	str.size();
			S32	uiPoint	=	uiStrSize;
			S32	uiSlash	=	-1;


			for(S32 i=uiStrSize-1;i>-1;i--){
				if(str[i]	==	'.'	&&	uiPoint	==	uiStrSize){
					uiPoint	=	i;
				}
				if(	str[i]	==	'/'	||
					str[i]	==	'\\'){
					uiSlash	=	i;
					break;
				}
			}

			if(	uiPoint	!=	uiStrSize	&&
				strExe	!=	NULL)
			{
				if(uiPoint!=uiStrSize-1)
					*strExe	=	&str[uiPoint+1];
			}

			if(	uiSlash	!=	-1		&&
				strPath	!=	NULL)
			{
				if(uiSlash<uiStrSize){
					strPath->resize(uiSlash+1);
					memcpy(&((*strPath)[0]),&str[0],uiSlash+1);
				}else{
					*strPath	=	str;
				}
			}

			if(strFileName!=NULL){
				U32	uiFileNameSize	=	uiPoint;
				U32	uiFileNameStart	=	0;
				if(uiPoint==uiStrSize)
					uiFileNameSize--;

				if(uiSlash<uiStrSize){
					if(uiSlash!=-1){
						uiFileNameSize	-=		uiSlash+1;
						uiFileNameStart	=		uiSlash+1;
					}

					strFileName->resize(uiFileNameSize);
					memcpy(&((*strFileName)[0]),&str[uiFileNameStart],uiFileNameSize);
				}
			}
			return	true;
		}
示例#19
0
cPublicKey::cPublicKey(const AString & a_PublicKeyDER)
{
	pk_init(&m_Pk);
	if (pk_parse_public_key(&m_Pk, (const Byte *)a_PublicKeyDER.data(), a_PublicKeyDER.size()) != 0)
	{
		ASSERT(!"Cannot parse PubKey");
		return;
	}
	InitRnd();
}
示例#20
0
//liluchangyou
void ARTSPConnection::onSendResponse(const sp<AMessage> &msg) {

    AString response;
	sp<AMessage> notify;
    CHECK(msg->findString("response", &response));

    // Find the boundary between headers and the body.
    ssize_t i = response.find("\r\n\r\n");
    CHECK_GE(i, 0);

    LOGI(LOG_TAG,"response:\n%s", response.c_str());

    size_t numBytesSent = 0;
    while (numBytesSent < response.size()) {
        ssize_t n =
            send(mSocket, response.c_str() + numBytesSent,
                 response.size() - numBytesSent, 0);

        if (n == 0) {
            // Client closed the connection.
            LOGE(LOG_TAG,"Client unexpectedly closed the connection.");
			mState = DISCONNECTED;
			notify = new AMessage(kwhatCloseSession,mhandlerID);
			notify->setInt32("result",-1);
			notify->setInt32("sessionID",mSessionID);
			notify->post();		
            return;
        } else if (n < 0) {
            if (errno == EINTR) {
                continue;
            }
			mState = DISCONNECTED;
            LOGE(LOG_TAG,"Error sending rtsp response.");
			notify = new AMessage(kwhatCloseSession,mhandlerID);
			notify->setInt32("result",errno );
			notify->setInt32("sessionID",mSessionID);
			notify->post();		
            return;
        }

        numBytesSent += (size_t)n;
    }
}
示例#21
0
// static
void HTTPStream::RegisterSocketUser(int s, uid_t uid) {
    // Lower bits MUST be 0.
    static const uint64_t kTag = 0xdeadbeef00000000ll;

    AString line = StringPrintf("t %d %llu %d", s, kTag, uid);

    int fd = open("/proc/net/xt_qtaguid/ctrl", O_WRONLY);
    write(fd, line.c_str(), line.size());
    close(fd);
    fd = -1;
}
示例#22
0
bool cSchematicFileSerializer::LoadFromSchematicString(cBlockArea & a_BlockArea, const AString & a_SchematicData)
{
	// Uncompress the data:
	AString UngzippedData;
	if (UncompressStringGZIP(a_SchematicData.data(), a_SchematicData.size(), UngzippedData) != Z_OK)
	{
		LOG("%s: Cannot unGZip the schematic data.", __FUNCTION__);
		return false;
	}

	// Parse the NBT:
	cParsedNBT NBT(UngzippedData.data(), UngzippedData.size());
	if (!NBT.IsValid())
	{
		LOG("%s: Cannot parse the NBT in the schematic data.", __FUNCTION__);
		return false;
	}

	return LoadFromSchematicNBT(a_BlockArea, NBT);
}
	AString HawkOSOperator::SplitFileName(const AString& sFile)
	{
		AString sTmpFile = sFile;
		HawkStringUtil::Replace<AString>(sTmpFile,"\\","/");
		Int32 iPos = (Int32)sTmpFile.find_last_of('/');
		if (iPos > 0)
		{
			return sTmpFile.substr(iPos+1,sTmpFile.size()-iPos-1);
		}
		return sTmpFile;
	}
示例#24
0
文件: utils.cpp 项目: Asmageddon/r1
std::vector<AString> split(const std::string& str, const char& chr) {
    std::vector<AString> result;
    AString current = AString("");
    for(unsigned int i = 0; i < str.size(); i++) {
        char c = str[i];
        if (c == chr){
            if (current.size() > 0) {
                result.push_back(current);
                current = AString("");
            }
        }
        else
            current += c;
    }
    if (current.size() > 0) {
        result.push_back(current);
        current = AString("");
    }
    return result;
}
示例#25
0
cCryptoKey::cCryptoKey(const AString & a_PublicKeyData)
{
	pk_init(&m_Pk);
	m_CtrDrbg.Initialize("rsa_pubkey", 10);
	int res = ParsePublic(a_PublicKeyData.data(), a_PublicKeyData.size());
	if (res != 0)
	{
		LOGWARNING("Failed to parse public key: -0x%x", res);
		ASSERT(!"Cannot parse PubKey");
		return;
	}
}
示例#26
0
void cProtocolRecognizer::DataReceived(const char * a_Data, size_t a_Size)
{
	if (m_Protocol == nullptr)
	{
		if (!m_Buffer.Write(a_Data, a_Size))
		{
			m_Client->Kick("Unsupported protocol version");
			return;
		}

		if (m_InPingForUnrecognizedVersion)
		{
			// We already know the verison; handle it here.
			UInt32 PacketLen;
			UInt32 PacketID;
			if (!m_Buffer.ReadVarInt32(PacketLen))
			{
				return;
			}
			if (!m_Buffer.ReadVarInt32(PacketID))
			{
				return;
			}
			ASSERT(PacketID == 0x01);  // Ping packet
			ASSERT(PacketLen == 9);  // Payload of the packet ID and a UInt64

			Int64 Data;
			if (!m_Buffer.ReadBEInt64(Data))
			{
				return;
			}

			cPacketizer Pkt(*this, 0x01);  // Pong packet
			Pkt.WriteBEInt64(Data);
			return;
		}

		if (!TryRecognizeProtocol())
		{
			return;
		}

		// The protocol has just been recognized, dump the whole m_Buffer contents into it for parsing:
		AString Dump;
		m_Buffer.ResetRead();
		m_Buffer.ReadAll(Dump);
		m_Protocol->DataReceived(Dump.data(), Dump.size());
	}
	else
	{
		m_Protocol->DataReceived(a_Data, a_Size);
	}
}
示例#27
0
cCryptoKey::cCryptoKey(const AString & a_PrivateKeyData, const AString & a_Password)
{
	pk_init(&m_Pk);
	m_CtrDrbg.Initialize("rsa_privkey", 11);
	int res = ParsePrivate(a_PrivateKeyData.data(), a_PrivateKeyData.size(), a_Password);
	if (res != 0)
	{
		LOGWARNING("Failed to parse private key: -0x%x", res);
		ASSERT(!"Cannot parse PubKey");
		return;
	}
}
示例#28
0
bool cByteBuffer::WriteBEUTF16String16(const AString & a_Value)
{
	CHECK_THREAD;
	CheckValid();
	PUTBYTES(2);
	AString UTF16BE;
	UTF8ToRawBEUTF16(a_Value.data(), a_Value.size(), UTF16BE);
	WriteBEShort((short)(UTF16BE.size() / 2));
	PUTBYTES(UTF16BE.size());
	WriteBuf(UTF16BE.data(), UTF16BE.size());
	return true;
}
void exportResultsToXML(
        const char *fileName,
        const CodecSettings &global_results,
        const KeyedVector<AString, CodecSettings> &encoder_results,
        const KeyedVector<AString, CodecSettings> &decoder_results) {
    if (global_results.size() == 0 && encoder_results.size() == 0 && decoder_results.size() == 0) {
        return;
    }

    AString overrides;
    overrides.append(getProfilingVersionString());
    overrides.append("\n");
    overrides.append("<MediaCodecs>\n");
    if (global_results.size() > 0) {
        overrides.append("    <Settings>\n");
        overrides.append(globalResultsToXml(global_results));
        overrides.append("    </Settings>\n");
    }
    if (encoder_results.size() > 0) {
        overrides.append("    <Encoders>\n");
        overrides.append(codecResultsToXml(encoder_results));
        overrides.append("    </Encoders>\n");
    }
    if (decoder_results.size() > 0) {
        overrides.append("    <Decoders>\n");
        overrides.append(codecResultsToXml(decoder_results));
        overrides.append("    </Decoders>\n");
    }
    overrides.append("</MediaCodecs>\n");

    FILE *f = fopen(fileName, "wb");
    if (f == NULL) {
        ALOGE("Failed to open %s for writing.", fileName);
        return;
    }
    if (fwrite(overrides.c_str(), 1, overrides.size(), f) != overrides.size()) {
        ALOGE("Failed to write to %s.", fileName);
    }
    fclose(f);
}
示例#30
0
void cHTTPFormParser::OnPartHeader(const AString & a_Key, const AString & a_Value)
{
	if (NoCaseCompare(a_Key, "Content-Disposition") == 0)
	{
		size_t len = a_Value.size();
		size_t ParamsStart = AString::npos;
		for (size_t i = 0; i < len; ++i)
		{
			if (a_Value[i] > ' ')
			{
				if (strncmp(a_Value.c_str() + i, "form-data", 9) != 0)
				{
					// Content disposition is not "form-data", mark the whole form invalid
					m_IsValid = false;
					return;
				}
				ParamsStart = a_Value.find(';', i + 9);
				break;
			}
		}
		if (ParamsStart == AString::npos)
		{
			// There is data missing in the Content-Disposition field, mark the whole form invalid:
			m_IsValid = false;
			return;
		}
		
		// Parse the field name and optional filename from this header:
		cNameValueParser Parser(a_Value.data() + ParamsStart, a_Value.size() - ParamsStart);
		Parser.Finish();
		m_CurrentPartName = Parser["name"];
		if (!Parser.IsValid() || m_CurrentPartName.empty())
		{
			// The required parameter "name" is missing, mark the whole form invalid:
			m_IsValid = false;
			return;
		}
		m_CurrentPartFileName = Parser["filename"];
	}
}