diff -r 000000000000 -r 33413c0669b9 vpnengine/ikev2lib/inc/ikev2message.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/vpnengine/ikev2lib/inc/ikev2message.h Thu Dec 17 09:14:51 2009 +0200 @@ -0,0 +1,377 @@ +/* +* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Class to represent IKEv2 payloads and to construct IKEv2 datagrams +* +*/ + +#ifndef IKEV2MESSAGE_H_ +#define IKEV2MESSAGE_H_ + +#include + +class CIkeCaList; +class CDesC8Array; +class TIkeV2TrafficSelector; +class CIkeV2Identity; + +NONSHARABLE_CLASS(CIkeV2Payload) : public CBase + { +public: + ~CIkeV2Payload(); + + TUint8 NextPayload() const; + void SetNextPayload(TUint8 aNextPayload); + + TUint16 PayloadLength() const; + void SetPayloadLength(TUint16 aLength); + + TPtrC8 PayloadData() const; + TUint8 PayloadType() const; + +protected: + CIkeV2Payload(TUint8 aPayloadType); + + HBufC8* iPayloadData; + +private: + TUint8 iPayloadType; + }; + + +NONSHARABLE_CLASS(CIkevV2CertReqPayload) : public CIkeV2Payload + { +public: + static CIkevV2CertReqPayload* NewL(const CIkeCaList& aCaList); + +private: + CIkevV2CertReqPayload(); + void ConstructL(const CIkeCaList& aCaList); + }; + +NONSHARABLE_CLASS(CIkevV2CertPayload) : public CIkeV2Payload + { +public: + static CIkevV2CertPayload* NewL(const TDesC8& aCertData); + +private: + CIkevV2CertPayload(); + void ConstructL(const TDesC8& aCertData); + }; + + + +NONSHARABLE_CLASS(CIkevV2SaPayload) : public CIkeV2Payload + { +public: + static CIkevV2SaPayload* NewL(const TDesC8& aSaData); + +private: + CIkevV2SaPayload(); + void ConstructL(const TDesC8& aSaData); + + }; + + +NONSHARABLE_CLASS(CIkevV2KePayload) : public CIkeV2Payload + { +public: + static CIkevV2KePayload* NewL(TUint16 aDHGroup, const TDesC8& aKeData); + +private: + CIkevV2KePayload(); + void ConstructL(TUint16 aDHGroup, const TDesC8& aKeData); + }; + + +NONSHARABLE_CLASS(CIkevV2NoncePayload) : public CIkeV2Payload + { +public: + static CIkevV2NoncePayload* NewL(const TDesC8& aNonceData); + +private: + CIkevV2NoncePayload(); + void ConstructL(const TDesC8& aNonceData); + }; + + +NONSHARABLE_CLASS(CIkevV2IdPayload) : public CIkeV2Payload + { +protected: + CIkevV2IdPayload(TUint8 aPayloadType); + void ConstructL(const CIkeV2Identity& aIdentity); + }; + +NONSHARABLE_CLASS(CIkevV2IdiPayload) : public CIkevV2IdPayload + { +public: + static CIkevV2IdiPayload* NewL(const CIkeV2Identity& aIdentity); + +private: + CIkevV2IdiPayload(); + }; + + +NONSHARABLE_CLASS(CIkevV2IdrPayload) : public CIkevV2IdPayload + { +public: + static CIkevV2IdrPayload* NewL(const CIkeV2Identity& aIdentity); + +private: + CIkevV2IdrPayload(); + }; + + +NONSHARABLE_CLASS(CIkeV2AuthPayload) : public CIkeV2Payload + { +public: + static CIkeV2AuthPayload* NewL(TUint8 aAuthMethod, const TDesC8& aAuthData); + +private: + CIkeV2AuthPayload(); + void ConstructL(TUint8 aAuthMethod, const TDesC8& aAuthData); + }; + + +NONSHARABLE_CLASS(CIkeV2NotifyPayload) : public CIkeV2Payload + { +public: + static CIkeV2NotifyPayload* NewL(TUint8 aProtocolId, + const TDesC8& aSpi, + TUint16 aNotifyType, + const TDesC8& aNotifyData); + +private: + CIkeV2NotifyPayload(); + void ConstructL(TUint8 aProtocolId, + const TDesC8& aSpi, + TUint16 aNotifyType, + const TDesC8& aNotifyData); + }; + + +NONSHARABLE_CLASS(CIkeV2ConfigurationPayload) : public CIkeV2Payload + { +public: + static CIkeV2ConfigurationPayload* NewL(TUint8 aCfgType, + const TDesC8& aConfigurationData); + +private: + CIkeV2ConfigurationPayload(); + void ConstructL(TUint8 aCfgType, + const TDesC8& aConfigurationData); + }; + + +NONSHARABLE_CLASS(CIkeV2VendorIdPayload) : public CIkeV2Payload + { +public: + static CIkeV2VendorIdPayload* NewL(const TDesC8& aVendorIdData); + +private: + CIkeV2VendorIdPayload(); + void ConstructL(const TDesC8& aVendorIdData); + }; + + +NONSHARABLE_CLASS(CIkeV2DeletePayload) : public CIkeV2Payload + { +public: + static CIkeV2DeletePayload* NewL(TUint8 aProtocolId, const CDesC8Array& aSpiList); + +private: + CIkeV2DeletePayload(); + void ConstructL(TUint8 aProtocolId, const CDesC8Array& aSpiList); + }; + + +NONSHARABLE_CLASS(CIkeV2EapPayload) : public CIkeV2Payload + { +public: + static CIkeV2EapPayload* NewL(const TDesC8& aEapData); + +private: + CIkeV2EapPayload(); + void ConstructL(const TDesC8& aEapData); + }; + + +NONSHARABLE_CLASS(CIkeV2TsPayload) : public CIkeV2Payload + { +protected: + CIkeV2TsPayload(TUint aPayloadType); + void ConstructL(const CArrayFix& aTsList); + }; + +class CIkeV2TsiPayload : public CIkeV2TsPayload + { +public: + static CIkeV2TsiPayload* NewL(const CArrayFix& aTsList); + +private: + CIkeV2TsiPayload(); + }; + +NONSHARABLE_CLASS(CIkeV2TsrPayload) : public CIkeV2TsPayload + { +public: + static CIkeV2TsrPayload* NewL(const CArrayFix& aTsList); + +private: + CIkeV2TsrPayload(); + }; + + +NONSHARABLE_CLASS(CIkeV2EncryptedPayload) : public CIkeV2TsPayload + { +public: + static CIkeV2EncryptedPayload* NewL(TUint aBlockSize); + + TUint BlockSize() const; + TPtrC8 InitializationVector() const; + + void SetContentLength(TUint16 aLength); +private: + CIkeV2EncryptedPayload(); + void ConstructL(TUint aBlockSize); + + TUint iBlockSize; + }; + +class MIkeDebug; +class TInetAddr; + +NONSHARABLE_CLASS(CIkeV2Message) : public CBase + { +public: + + /** + * Constructs new IKE message. + * + * @param aInitiatorSpi Initiator SPI + * @param aResponderSpi Responder SPI + * @param aExchangeType Type of the exchange. Possible values are: + * IKE_SA_INIT, IKE_AUTH, CREATE_CHILD_SA and INFORMATIONAL. + * @param aFlags Message flags. Possible flags are: + * IKEV2_INITIATOR and IKEV2_RESPONSE_MSG. + */ + static CIkeV2Message* NewL(const TDesC8& aInitiatorSpi, + const TDesC8& aResponderSpi, + TUint8 aExchangeType, + TBool aIntiator, + TBool aResponse, + TUint32 aMessageId, + MIkeDebug& aDebug); + ~CIkeV2Message(); + + TPtrC8 InitiatorSpi()const; + TPtrC8 ResponderSpi() const; + + TUint8 NextPayload() const; + + TUint8 MajorVersion() const; + TUint8 MinorVersion() const; + + TUint8 ExchangeType() const; + + TUint8 Flags() const; + + TUint32 MessageId() const; + + TUint32 Length() const; + + void AppendCertReqPayloadL(const CIkeCaList& aCaList); + void AppendCertPayloadL(const TDesC8& aCertificateData); + void AppendSaPayloadL(const TDesC8& aSaData); + void AppendKePayloadL(TUint16 aDHGroup, const TDesC8& aKeData); + void AppendNoncePayloadL(const TDesC8& aNonceData); + void AppendIdiPayloadL(const CIkeV2Identity& aIdentity); + void AppendIdrPayloadL(const CIkeV2Identity& aIdentity); + void AppendAuthPayloadL(TUint8 aAuthMethod, const TDesC8& aAuthData); + void AppendNotifyPayloadL(TUint8 aProtocolId, + const TDesC8& aSpi, + TUint16 aNotifyType, + const TDesC8& aNotifyData); + + /** + * A special method for adding a cookie notify in the + * beginning of an existing ike message. + */ + void PrependCookieNotifyPayloadL(const TDesC8& aCookieData); + + void AppendConfigurationPayloadL(TUint8 aCfgType, + const TDesC8& aConfigurationData); + void AppendVendorIdPayloadL(const TDesC8& aVendorIdData); + void AppendDeletePayloadL(TUint8 aProtocolId, const CDesC8Array& aSpiList); + void AppendEapPayloadL(const TDesC8& aEapData); + void AppendTsiPayloadL(const CArrayFix& aTsList); + void AppendTsrPayloadL(const CArrayFix& aTsList); + + /** + * Adds the encrypted payload to the message. + * The added encrypted payload has to be the first added payload. + */ + void AppendEncryptedPayloadL(TUint aBlockSize); + + + /** + * Gets the ike message datagram, which is ready to be + * send to the receiver. + * + * @param aEncryptionAlgorith Encryption algorithm to be used to encrypt the datagram. + * If the message does not contain an encryption payload, this + * parameter is ignored. + * @param aEncryptionKey Encryption key used to used to encrypt the datagram. + * If the message does not contain an encryption payload, this + * parameter is ignored. + * @param aIntegrityAlgorithm Algorithm used to calculate the integrity checks sum. + * If the message does not contain an encryption payload, this + * parameter is ignored. + * @param aSourceAddress Source address of the datagram. Needed for message tracing in + * debug builds. + * @param aDestinationAddress Destination address of the datagram. Needed for message tracing in + * debug builds. + */ + void PrepareIkeMessageDatagramL(TUint16 aEncryptionAlgorithm, + const TDesC8& aEncryptionKey, + TUint16 aIntegrityAlgorithm, + const TDesC8& aIntegrityKey, + const TInetAddr& aSourceAddress, + const TInetAddr& aDestinationAddress); + + TPtrC8 IkeMessageDatagram() const; +private: + CIkeV2Message(MIkeDebug& aDebug); + void ConstructL(const TDesC8& aInitiatorSpi, + const TDesC8& aResponderSpi, + TUint8 aExchangeType, + TBool aIntiator, + TBool aResponse, + TUint32 aMessageId); + + void AppendPayloadL(CIkeV2Payload* aPayload); + + void SetFlags(TUint8 aFlags); + void SetLength(TUint32 aDatagramLength); + void SetNextPayload(TUint8 aNextPayload); + + + MIkeDebug& iDebug; + HBufC8* iIkeV2MessageHeader; + RPointerArray iPayloads; + + TBool iModified; + HBufC8* iIkeV2Datagram; + }; + +#endif /* IKEV2MESSAGE_H_ */