while (AnyRetrievable())			{				transferedBytes = ULONG_MAX;				blockedBytes = TransferTo2(target, transferedBytes, channel, blocking);				if (blockedBytes > 0)					return blockedBytes;			}			if (target.ChannelMessageEnd(channel, GetAutoSignalPropagation(), blocking))				return 1;			bool result = GetNextMessage();			assert(result);		}		return 0;	}}unsigned int BufferedTransformation::CopyMessagesTo(BufferedTransformation &target, unsigned int count, const std::string &channel) const{	if (AttachedTransformation())		return AttachedTransformation()->CopyMessagesTo(target, count, channel);	else		return 0;}void BufferedTransformation::SkipAll(){	if (AttachedTransformation())		AttachedTransformation()->SkipAll();	else	{		while (SkipMessages()) {}		while (Skip()) {}	}}unsigned int BufferedTransformation::TransferAllTo2(BufferedTransformation &target, const std::string &channel, bool blocking){	if (AttachedTransformation())		return AttachedTransformation()->TransferAllTo2(target, channel, blocking);	else	{		assert(!NumberOfMessageSeries());		unsigned int messageCount;		do		{			messageCount = UINT_MAX;			unsigned int blockedBytes = TransferMessagesTo2(target, messageCount, channel, blocking);			if (blockedBytes)				return blockedBytes;		}		while (messageCount != 0);		unsigned long byteCount;		do		{			byteCount = ULONG_MAX;			unsigned int blockedBytes = TransferTo2(target, byteCount, channel, blocking);			if (blockedBytes)				return blockedBytes;		}		while (byteCount != 0);		return 0;	}}void BufferedTransformation::CopyAllTo(BufferedTransformation &target, const std::string &channel) const{	if (AttachedTransformation())		AttachedTransformation()->CopyAllTo(target, channel);	else	{		assert(!NumberOfMessageSeries());		while (CopyMessagesTo(target, UINT_MAX, channel)) {}	}}void BufferedTransformation::SetRetrievalChannel(const std::string &channel){	if (AttachedTransformation())		AttachedTransformation()->SetRetrievalChannel(channel);}unsigned int BufferedTransformation::ChannelPutWord16(const std::string &channel, word16 value, ByteOrder order, bool blocking){	FixedSizeSecBlock<byte, 2> buf;	PutWord(false, order, buf, value);	return ChannelPut(channel, buf, 2, blocking);}unsigned int BufferedTransformation::ChannelPutWord32(const std::string &channel, word32 value, ByteOrder order, bool blocking){	FixedSizeSecBlock<byte, 4> buf;	PutWord(false, order, buf, value);	return ChannelPut(channel, buf, 4, blocking);}unsigned int BufferedTransformation::PutWord16(word16 value, ByteOrder order, bool blocking){	return ChannelPutWord16(NULL_CHANNEL, value, order, blocking);}unsigned int BufferedTransformation::PutWord32(word32 value, ByteOrder order, bool blocking){	return ChannelPutWord32(NULL_CHANNEL, value, order, blocking);}unsigned int BufferedTransformation::PeekWord16(word16 &value, ByteOrder order){	byte buf[2] = {0, 0};	unsigned int len = Peek(buf, 2);	if (order)		value = (buf[0] << 8) | buf[1];	else		value = (buf[1] << 8) | buf[0];	return len;}unsigned int BufferedTransformation::PeekWord32(word32 &value, ByteOrder order){	byte buf[4] = {0, 0, 0, 0};	unsigned int len = Peek(buf, 4);	if (order)		value = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf [3];	else		value = (buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf [0];	return len;}unsigned int BufferedTransformation::GetWord16(word16 &value, ByteOrder order){	return Skip(PeekWord16(value, order));}unsigned int BufferedTransformation::GetWord32(word32 &value, ByteOrder order){	return Skip(PeekWord32(value, order));}void BufferedTransformation::Attach(BufferedTransformation *newOut){	if (AttachedTransformation() && AttachedTransformation()->Attachable())		AttachedTransformation()->Attach(newOut);	else		Detach(newOut);}void GeneratableCryptoMaterial::GenerateRandomWithKeySize(RandomNumberGenerator &rng, unsigned int keySize){	GenerateRandom(rng, MakeParameters("KeySize", (int)keySize));}BufferedTransformation * PK_Encryptor::CreateEncryptionFilter(RandomNumberGenerator &rng, BufferedTransformation *attachment) const{	struct EncryptionFilter : public Unflushable<FilterWithInputQueue>	{		// VC60 complains if this function is missing		EncryptionFilter(const EncryptionFilter &x) : Unflushable<FilterWithInputQueue>(NULL), m_rng(x.m_rng), m_encryptor(x.m_encryptor) {}		EncryptionFilter(RandomNumberGenerator &rng, const PK_Encryptor &encryptor, BufferedTransformation *attachment)			: Unflushable<FilterWithInputQueue>(attachment), m_rng(rng), m_encryptor(encryptor)		{		}		bool IsolatedMessageEnd(bool blocking)		{			switch (m_continueAt)			{			case 0:				{				unsigned int plaintextLength = m_inQueue.CurrentSize();				m_ciphertextLength = m_encryptor.CiphertextLength(plaintextLength);				SecByteBlock plaintext(plaintextLength);				m_inQueue.Get(plaintext, plaintextLength);				m_ciphertext.resize(m_ciphertextLength);				m_encryptor.Encrypt(m_rng, plaintext, plaintextLength, m_ciphertext);				}			case 1:				if (!Output(1, m_ciphertext, m_ciphertextLength, 0, blocking))					return false;			};			return true;		}		RandomNumberGenerator &m_rng;		const PK_Encryptor &m_encryptor;		unsigned int m_ciphertextLength;		SecByteBlock m_ciphertext;	};	return new EncryptionFilter(rng, *this, attachment);}BufferedTransformation * PK_Decryptor::CreateDecryptionFilter(RandomNumberGenerator &rng, BufferedTransformation *attachment) const{	struct DecryptionFilter : public Unflushable<FilterWithInputQueue>	{		// VC60 complains if this function is missing		DecryptionFilter(const DecryptionFilter &x) : Unflushable<FilterWithInputQueue>(NULL), m_rng(x.m_rng), m_decryptor(x.m_decryptor) {}		DecryptionFilter(RandomNumberGenerator &rng, const PK_Decryptor &decryptor, BufferedTransformation *attachment)			: Unflushable<FilterWithInputQueue>(attachment), m_rng(rng), m_decryptor(decryptor)		{		}		bool IsolatedMessageEnd(bool blocking)		{			switch (m_continueAt)			{			case 0:				{				unsigned int ciphertextLength = m_inQueue.CurrentSize();				unsigned int maxPlaintextLength = m_decryptor.MaxPlaintextLength(ciphertextLength);				SecByteBlock ciphertext(ciphertextLength);				m_inQueue.Get(ciphertext, ciphertextLength);				m_plaintext.resize(maxPlaintextLength);				m_result = m_decryptor.Decrypt(m_rng, ciphertext, ciphertextLength, m_plaintext);				if (!m_result.isValidCoding)					throw InvalidCiphertext(m_decryptor.AlgorithmName() + ": invalid ciphertext");				}			case 1:				if (!Output(1, m_plaintext, m_result.messageLength, 0, blocking))					return false;			}			return true;		}		RandomNumberGenerator &m_rng;		const PK_Decryptor &m_decryptor;		SecByteBlock m_plaintext;		DecodingResult m_result;	};	return new DecryptionFilter(rng, *this, attachment);}unsigned int PK_FixedLengthCryptoSystem::MaxPlaintextLength(unsigned int cipherTextLength) const{	if (cipherTextLength == FixedCiphertextLength())		return FixedMaxPlaintextLength();	else		return 0;}unsigned int PK_FixedLengthCryptoSystem::CiphertextLength(unsigned int plainTextLength) const{	if (plainTextLength <= FixedMaxPlaintextLength())		return FixedCiphertextLength();	else		return 0;}DecodingResult PK_FixedLengthDecryptor::Decrypt(RandomNumberGenerator &rng, const byte *cipherText, unsigned int cipherTextLength, byte *plainText) const{	if (cipherTextLength != FixedCiphertextLength())		return DecodingResult();	return FixedLengthDecrypt(rng, cipherText, plainText);}unsigned int PK_Signer::Sign(RandomNumberGenerator &rng, PK_MessageAccumulator *messageAccumulator, byte *signature) const{	std::auto_ptr<PK_MessageAccumulator> m(messageAccumulator);	return SignAndRestart(rng, *m, signature, false);}unsigned int PK_Signer::SignMessage(RandomNumberGenerator &rng, const byte *message, unsigned int messageLen, byte *signature) const{	std::auto_ptr<PK_MessageAccumulator> m(NewSignatureAccumulator(rng));	m->Update(message, messageLen);	return SignAndRestart(rng, *m, signature, false);}unsigned int PK_Signer::SignMessageWithRecovery(RandomNumberGenerator &rng, const byte *recoverableMessage, unsigned int recoverableMessageLength, 	const byte *nonrecoverableMessage, unsigned int nonrecoverableMessageLength, byte *signature) const{	std::auto_ptr<PK_MessageAccumulator> m(NewSignatureAccumulator(rng));	InputRecoverableMessage(*m, recoverableMessage, recoverableMessageLength);	m->Update(nonrecoverableMessage, nonrecoverableMessageLength);	return SignAndRestart(rng, *m, signature, false);}bool PK_Verifier::Verify(PK_MessageAccumulator *messageAccumulator) const{	std::auto_ptr<PK_MessageAccumulator> m(messageAccumulator);	return VerifyAndRestart(*m);}bool PK_Verifier::VerifyMessage(const byte *message, unsigned int messageLen, const byte *signature, unsigned int signatureLength) const{	std::auto_ptr<PK_MessageAccumulator> m(NewVerificationAccumulator());	InputSignature(*m, signature, signatureLength);	m->Update(message, messageLen);	return VerifyAndRestart(*m);}DecodingResult PK_Verifier::Recover(byte *recoveredMessage, PK_MessageAccumulator *messageAccumulator) const{	std::auto_ptr<PK_MessageAccumulator> m(messageAccumulator);	return RecoverAndRestart(recoveredMessage, *m);}DecodingResult PK_Verifier::RecoverMessage(byte *recoveredMessage, 	const byte *nonrecoverableMessage, unsigned int nonrecoverableMessageLength, 	const byte *signature, unsigned int signatureLength) const{	std::auto_ptr<PK_MessageAccumulator> m(NewVerificationAccumulator());	InputSignature(*m, signature, signatureLength);	m->Update(nonrecoverableMessage, nonrecoverableMessageLength);	return RecoverAndRestart(recoveredMessage, *m);}void SimpleKeyAgreementDomain::GenerateKeyPair(RandomNumberGenerator &rng, byte *privateKey, byte *publicKey) const{	GeneratePrivateKey(rng, privateKey);	GeneratePublicKey(rng, privateKey, publicKey);}void AuthenticatedKeyAgreementDomain::GenerateStaticKeyPair(RandomNumberGenerator &rng, byte *privateKey, byte *publicKey) const{	GenerateStaticPrivateKey(rng, privateKey);	GenerateStaticPublicKey(rng, privateKey, publicKey);}void AuthenticatedKeyAgreementDomain::GenerateEphemeralKeyPair(RandomNumberGenerator &rng, byte *privateKey, byte *publicKey) const{	GenerateEphemeralPrivateKey(rng, privateKey);	GenerateEphemeralPublicKey(rng, privateKey, publicKey);}NAMESPACE_END