1 // Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // The DHCPv6 States header file

    15 // 

    16 //

    17 

    18 /**

    19  @file DHCPIP6States.h

    20 */

    21 

    22 #ifndef __DHCPIP6STATES_H__

    23 #define __DHCPIP6STATES_H__

    24 

    25 #include "DHCPStates.h"

    26 #include "DHCPIP6StateMachine.h"

    27 

    28 #ifdef SYMBIAN_ESOCK_V3

    29 #include <networking/ipeventtypes.h>

    30 #include <comms-infras/netsignalevent.h>

    31 

    32 namespace NetSubscribe

    33 {

    34 class CNetSubscribe;

    35 }

    36 

    37 class CDHCPIP6ListenToNeighbor : public SDhcpSignal, public CDHCPState, public MExpireTimer

    38 	{

    39 public:	

    40 	CDHCPIP6ListenToNeighbor(CDHCPIP6StateMachine& aDHCPIPv6) :

    41 		CDHCPState(aDHCPIPv6),

    42 		iEvent( this, SignalHandlerFn ),

    43 		iErr( KErrNone ),

    44 		iMFlag( 0 ), //default act as if we haven't got it

    45 		iOFlag( 0 ) //default act as if we haven't got it

    46 		{

    47 		}

    48 	~CDHCPIP6ListenToNeighbor();

    49 	

    50 	virtual CAsynchEvent* ProcessL(TRequestStatus& aStatus);

    51 	virtual void TimerExpired();

    52 	void BecomeIdle();

    53 	virtual void Cancel();

    54 	void CompleteClientAndStartInform();

    55 

    56 	CDHCPIP6StateMachine& DHCPIPv6()

    57 		{

    58 		return static_cast<CDHCPIP6StateMachine&>(*iStateMachine);

    59 		}

    60 

    61 protected:

    62 	static void SignalHandlerFn( TAny* aThis, const Meta::SMetaData* aData );

    63 	

    64 	NetSubscribe::TEvent iEvent;

    65 	TInt iErr; //to avoid infinite loop

    66 	TInt iMFlag;

    67 	TInt iOFlag;

    68 	};

    69 #endif

    70 

    71 class CDHCPIP6Solicit : public CDHCPAddressAcquisition

    72 	{

    73 public:

    74 	CDHCPIP6Solicit(CDHCPIP6StateMachine& aDHCPIPv6,TInt aTimeOut = 0) :

    75 		CDHCPAddressAcquisition(aDHCPIPv6), iUserDefinedTimeout( aTimeOut )

    76 		{

    77 		}

    78 	virtual CAsynchEvent* ProcessL(TRequestStatus& aStatus);

    79 

    80 	CDHCPIP6StateMachine& DHCPIPv6()

    81 		{

    82 		return static_cast<CDHCPIP6StateMachine&>(*iStateMachine);

    83 		}

    84 private:

    85 	TInt iUserDefinedTimeout;		

    86 	};

    87 

    88 class CDHCPIP6Select : public CDHCPSelect, public MMSListener

    89 	{		

    90 public:

    91 	CDHCPIP6Select(CDHCPIP6StateMachine& aDHCPIPv6) :

    92 		CDHCPSelect(aDHCPIPv6),

    93 		iBestServerPreference(-1)

    94 		{		

    95 		}

    96 	~CDHCPIP6Select();

    97    //from CDHCPState->CActiveEvent

    98 	virtual CAsynchEvent* ProcessL(TRequestStatus& aStatus);

    99 	//from MMSListener

   100 	virtual TInt MSReportError(TInt aError);

   101 	void SetMaxRetryCount(TInt aMaxRetryCount);

   102 

   103 	CDHCPIP6StateMachine& DHCPIPv6()

   104 		{

   105 		return static_cast<CDHCPIP6StateMachine&>(*iStateMachine);

   106 		}

   107 protected:

   108    	TBool iDone;

   109 	TInt iMaxRetryCount;	//This used in MSReportError so we can control

   110 							//how many more times to try after an error.

   111 	TInt iBestServerPreference;

   112 	RBuf8 iSelectedMessage;

   113 	};

   114 

   115 class CDHCPIP6InformRequest : public CDHCPInformationConfig

   116 	{

   117 public:

   118 	CDHCPIP6InformRequest(CDHCPIP6StateMachine& aDHCPIPv6) :

   119 		CDHCPInformationConfig(aDHCPIPv6)

   120 		{

   121 		}

   122 

   123    virtual CAsynchEvent* ProcessL(TRequestStatus& aStatus);

   124 

   125 	CDHCPIP6StateMachine& DHCPIPv6()

   126 		{

   127 		return static_cast<CDHCPIP6StateMachine&>(*iStateMachine);

   128 		}

   129 	};

   130 

   131 class CDHCPIP6Request : public CDHCPRequest

   132 	{

   133 public:

   134 	CDHCPIP6Request(CDHCPIP6StateMachine& aDHCPIPv6) :

   135 		CDHCPRequest(aDHCPIPv6)

   136 		{

   137 		}

   138 

   139 	CDHCPIP6StateMachine& DHCPIPv6()

   140 		{

   141 		return static_cast<CDHCPIP6StateMachine&>(*iStateMachine);

   142 		}

   143 	};

   144 

   145 class CDHCPIP6Confirm : public CDHCPRebootConfirm

   146 	{

   147 public:

   148 	CDHCPIP6Confirm(CDHCPIP6StateMachine& aDHCPIPv6) :

   149 		CDHCPRebootConfirm(aDHCPIPv6)

   150 		{

   151 		}

   152    virtual CAsynchEvent* ProcessL(TRequestStatus& aStatus);

   153 

   154 	CDHCPIP6StateMachine& DHCPIPv6()

   155 		{

   156 		return static_cast<CDHCPIP6StateMachine&>(*iStateMachine);

   157 		}

   158 	};

   159 

   160 #if 0

   161 class CDHCPIP6WaitForDAD : public CDHCPWaitForDADIPNotifier

   162 	/** the class waits for DAD to finish and than takes next address from IA, set it and waits for DAD again until

   163 	all addresses have been verified and marked as valid/invalid. 

   164 	@see CDHCPIP6Control::TaskCompleteL

   165 	@internalComponent

   166 	*/

   167 	{

   168 public:

   169 	CDHCPIP6WaitForDAD(CDHCPIP6StateMachine& aDHCPIPv6) :

   170 		CDHCPWaitForDADBind(aDHCPIPv6),

   171 		iAddressIndex( 0 ) //the first address (index 0) is set when reply msg's been received

   172 		{

   173 		}

   174 

   175 	virtual CAsynchEvent* ProcessL(TRequestStatus& aStatus);

   176 

   177 	CDHCPIP6StateMachine& DHCPIPv6()

   178 		{

   179 		return static_cast<CDHCPIP6StateMachine&>(*iStateMachine);

   180 		}

   181 		

   182 protected:

   183 	TInt iAddressIndex;

   184 	};

   185 #else

   186 class CDHCPIP6WaitForDAD : public CDHCPWaitForDADBind

   187 	/** the class waits for DAD to finish and than takes next address from IA, set it and waits for DAD again until

   188 	all addresses have been verified and marked as valid/invalid. 

   189 	@see CDHCPIP6Control::TaskCompleteL

   190 	@internalComponent

   191 	*/

   192 	{

   193 public:

   194 	CDHCPIP6WaitForDAD(CDHCPIP6StateMachine& aDHCPIPv6) :

   195 		CDHCPWaitForDADBind(aDHCPIPv6),

   196 		iAddressIndex( 0 ) //the first address (index 0) is set when reply msg has been received

   197 		{

   198 		}

   199 

   200 	virtual CAsynchEvent* ProcessL(TRequestStatus& aStatus);

   201 	virtual void TimerExpired();

   202 

   203 	CDHCPIP6StateMachine& DHCPIPv6()

   204 		{

   205 		return static_cast<CDHCPIP6StateMachine&>(*iStateMachine);

   206 		}

   207 		

   208 protected:

   209 	TInt iAddressIndex;

   210 	};

   211 #endif

   212 

   213 class CDHCPIP6Renew : public CDHCPRenew

   214 	{

   215 public:

   216 	CDHCPIP6Renew(CDHCPIP6StateMachine& aDHCPIPv6) : CDHCPRenew(aDHCPIPv6),iUserDefinedTimeout(0)

   217 		{

   218 		}

   219 

   220 	CDHCPIP6Renew(CDHCPIP6StateMachine& aDHCPIPv6,TInt& aTimeOut) : CDHCPRenew(aDHCPIPv6),iUserDefinedTimeout(aTimeOut)

   221 		{

   222 		}

   223 

   224 		

   225 	//   ACK received => continue with next state (Bound)

   226 	virtual CAsynchEvent* ProcessL(TRequestStatus& aStatus);

   227 

   228 	CDHCPIP6StateMachine& DHCPIPv6()

   229 		{

   230 		return static_cast<CDHCPIP6StateMachine&>(*iStateMachine);

   231 		}

   232 private:

   233 	TInt iUserDefinedTimeout;		

   234 	};

   235 

   236 class CDHCPIP6Rebind : public CDHCPRebind

   237 	{

   238 public:

   239 	CDHCPIP6Rebind(CDHCPIP6StateMachine& aDHCPIPv6) : CDHCPRebind(aDHCPIPv6),iUserDefinedTimeout(0)

   240 		{		

   241 		}

   242 		

   243 	CDHCPIP6Rebind(CDHCPIP6StateMachine& aDHCPIPv6,TInt& aTimeOut) : CDHCPRebind(aDHCPIPv6),iUserDefinedTimeout(aTimeOut)

   244 		{

   245 		}

   246 	//   ACK received => continue with next state (Bound)

   247 	virtual CAsynchEvent* ProcessL(TRequestStatus& aStatus);

   248 

   249 	CDHCPIP6StateMachine& DHCPIPv6()

   250 		{

   251 		return static_cast<CDHCPIP6StateMachine&>(*iStateMachine);

   252 		}

   253 private:

   254 	TInt iUserDefinedTimeout;		

   255 	};

   256 

   257 class CDHCPIP6Reconfigure : public CDHCPRequest

   258 	{

   259 public:

   260 	CDHCPIP6Reconfigure(CDHCPIP6StateMachine& aDHCPIPv6) : CDHCPRequest(aDHCPIPv6)

   261 		{

   262 		}

   263 	virtual CAsynchEvent* ProcessL(TRequestStatus& aStatus);

   264 	virtual CDHCPState* ProcessAckNakL(TRequestStatus* aStatus);

   265 

   266 	CDHCPIP6StateMachine& DHCPIPv6()

   267 		{

   268 		return static_cast<CDHCPIP6StateMachine&>(*iStateMachine);

   269 		}

   270 	};

   271 

   272 class CDHCPIP6Release : public CDHCPRelease

   273 	{

   274 public:

   275 	CDHCPIP6Release(CDHCPIP6StateMachine& aDHCPIPv6) :

   276 		CDHCPRelease(aDHCPIPv6)

   277 		{

   278 		}

   279 	virtual CAsynchEvent* ProcessL(TRequestStatus& aStatus);

   280 

   281 	CDHCPIP6StateMachine& DHCPIPv6()

   282 		{

   283 		return static_cast<CDHCPIP6StateMachine&>(*iStateMachine);

   284 		}

   285 	};

   286 

   287 class CDHCPIP6Decline : public CDHCPDecline

   288 	{

   289 public:

   290 	CDHCPIP6Decline(CDHCPIP6StateMachine& aDHCPIPv6) :

   291 		CDHCPDecline(aDHCPIPv6)

   292 		{

   293 		}

   294 	//create msg sends it off

   295 	virtual CAsynchEvent* ProcessL(TRequestStatus& aStatus);

   296 

   297 	CDHCPIP6StateMachine& DHCPIPv6()

   298 		{

   299 		return static_cast<CDHCPIP6StateMachine&>(*iStateMachine);

   300 		}

   301 	};

   302 

   303 class CDHCPIP6ReplyNoBinding : public CDHCPRequest

   304 	{

   305 public:

   306 	CDHCPIP6ReplyNoBinding(CDHCPIP6StateMachine& aDHCPIPv6) :

   307 		CDHCPRequest(aDHCPIPv6)

   308 		{

   309 		}

   310 	virtual CDHCPState* ProcessAckNakL(TRequestStatus* aStatus);

   311 

   312 	CDHCPIP6StateMachine& DHCPIPv6()

   313 		{

   314 		return static_cast<CDHCPIP6StateMachine&>(*iStateMachine);

   315 		}

   316 	};

   317 

   318 #endif