--- /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 <e32base.h>
+
+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<TIkeV2TrafficSelector>& aTsList);
+ };
+
+class CIkeV2TsiPayload : public CIkeV2TsPayload
+ {
+public:
+ static CIkeV2TsiPayload* NewL(const CArrayFix<TIkeV2TrafficSelector>& aTsList);
+
+private:
+ CIkeV2TsiPayload();
+ };
+
+NONSHARABLE_CLASS(CIkeV2TsrPayload) : public CIkeV2TsPayload
+ {
+public:
+ static CIkeV2TsrPayload* NewL(const CArrayFix<TIkeV2TrafficSelector>& 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<TIkeV2TrafficSelector>& aTsList);
+ void AppendTsrPayloadL(const CArrayFix<TIkeV2TrafficSelector>& 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<CIkeV2Payload> iPayloads;
+
+ TBool iModified;
+ HBufC8* iIkeV2Datagram;
+ };
+
+#endif /* IKEV2MESSAGE_H_ */