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 DHCP States header file

    15 // 

    16 //

    17 

    18 /**

    19  @file DHCPStates.h

    20 */

    21 

    22 #ifndef __DHCPSTATES_H__

    23 #define __DHCPSTATES_H__

    24 

    25 #include <e32base.h>

    26 #include <comms-infras/asynchevent.h>

    27 #include "DHCPStateMachine.h"

    28 #ifdef SYMBIAN_ESOCK_V3

    29 #include <comms-infras/idquerynetmsg.h>

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

    31 #include <c32root.h>

    32 

    33 namespace NetSubscribe

    34 {

    35 class TEvent;

    36 }

    37 

    38 class SFactoryChannel

    39 	{

    40 public:

    41 	~SFactoryChannel();

    42 	SFactoryChannel()

    43 		{

    44 		}

    45 	void SendMessageL( NetMessages::CMessage& aMsg );

    46 	

    47 protected:

    48 	CommsFW::TCFModuleName iModule;

    49 	Elements::TRBuf8 iBuf;

    50 	RRootServ iC32Root;

    51 	};

    52 

    53 class SDhcpSignal : public SFactoryChannel

    54 	{

    55 public:

    56 	~SDhcpSignal();

    57 	SDhcpSignal()

    58 		{

    59 		}

    60 	void SubscribeL( const TName& aInterfaceName, TInt aEventId, NetSubscribe::TEvent& aEvent );

    61 	

    62 protected:

    63 	NetSubscribe::CNetSubscribe* iNetSubscribe;

    64 	NetMessages::CTypeIdQuery* iQuery;

    65 	};

    66 #endif

    67 

    68 class CDHCPState : public CAsynchEvent

    69 	{

    70 public:

    71 	CDHCPState(CDHCPStateMachine& aDHCP) :

    72 		CAsynchEvent(&aDHCP) 

    73 		{

    74 		}

    75 	virtual ~CDHCPState();

    76 

    77 	virtual CDHCPState* ProcessAckNakL(TRequestStatus* aStatus);

    78 	CDHCPStateMachine& Dhcp()

    79 		{

    80 		return static_cast<CDHCPStateMachine&>(*iStateMachine);

    81 		}

    82 	

    83 	virtual void Cancel();

    84 public:

    85 	enum EDHCPHistory //must be a bit mask

    86 		{

    87 		EBinding = 1,

    88 		EBindToSource = 2

    89 		};

    90 

    91 	};

    92 

    93 class CDHCPAddressAcquisition : public CDHCPState

    94 	{

    95 public:

    96 	CDHCPAddressAcquisition(CDHCPStateMachine& aDHCP) :

    97 		CDHCPState(aDHCP)

    98 		{

    99 		}

   100 	//create msg sends it off & initiates receive

   101 	virtual CAsynchEvent* ProcessL(TRequestStatus& aStatus);

   102 	};

   103 

   104 class CDHCPSelect : public CDHCPState

   105 	{

   106 public:

   107 	CDHCPSelect(CDHCPStateMachine& aDHCP) :

   108 		CDHCPState(aDHCP)

   109 		{

   110 		}

   111 	//create msg sends it off & initiates receive

   112 	virtual CAsynchEvent* ProcessL(TRequestStatus& aStatus);

   113 	};

   114 

   115 class CDHCPRebootConfirm : public CDHCPState

   116 	{

   117 public:

   118 	CDHCPRebootConfirm(CDHCPStateMachine& aDHCP) :

   119 		CDHCPState(aDHCP)

   120 		{

   121 		}

   122 	//create msg sends it off & initiates receive

   123 	virtual CAsynchEvent* ProcessL(TRequestStatus& aStatus);

   124 	};

   125 

   126 class CDHCPInformationConfig : public CDHCPState

   127 	{

   128 public:

   129 	CDHCPInformationConfig(CDHCPStateMachine& aDHCP) :

   130 		CDHCPState(aDHCP)

   131 		{

   132 		}

   133 	//create msg sends it off & initiates receive

   134 	virtual CAsynchEvent* ProcessL(TRequestStatus& aStatus);

   135 	};

   136 

   137 class CDHCPRequest : public CDHCPState

   138 	{

   139 public:

   140 	CDHCPRequest(CDHCPStateMachine& aDHCP) :

   141 		CDHCPState(aDHCP)

   142 		{

   143 		}

   144 	virtual CAsynchEvent* ProcessL( TRequestStatus& aStatus );

   145 	};

   146 

   147 class CDHCPWaitForDADBind : public CDHCPState, public MExpireTimer

   148 	{//uses RSocket::Bind to validate DAD

   149 public:

   150 	CDHCPWaitForDADBind(CDHCPStateMachine& aDHCP) :

   151 		CDHCPState(aDHCP)

   152 		{

   153 		}

   154 	virtual void TimerExpired();

   155 

   156 	//starts bind timer

   157 	virtual CAsynchEvent* ProcessL(TRequestStatus& aStatus);

   158 	

   159 	virtual void Cancel();

   160 protected:

   161 	TTime iBoundAt;

   162 	TInt iErr;

   163 	};

   164 

   165 #if 0

   166 class CDHCPWaitForDADIPNotifier : public CDHCPState, public CSubscribeChannel, public MExpireTimer

   167 	{//uses public&subscribe (IPEventNotifier component) to validate DAD

   168 public:

   169 	CDHCPWaitForDADIPNotifier(CDHCPStateMachine& aDHCP) :

   170 		CDHCPState(aDHCP)

   171 		{

   172 		}

   173 	virtual void TimerExpired();

   174 

   175 protected:

   176 	TTime iBoundAt;

   177 	};

   178 #endif

   179 

   180 class CDHCPRenew : public CDHCPState

   181 	{

   182 public:

   183 	CDHCPRenew(CDHCPStateMachine& aDHCP) : CDHCPState(aDHCP)

   184 		{

   185 		}

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

   187 	virtual CAsynchEvent* ProcessL(TRequestStatus& aStatus);

   188 	};

   189 

   190 class CDHCPRebind : public CDHCPState

   191 	{

   192 public:

   193 	CDHCPRebind(CDHCPStateMachine& aDHCP) : CDHCPState(aDHCP)

   194 		{

   195 		}

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

   197 	virtual CAsynchEvent* ProcessL(TRequestStatus& aStatus);

   198 	};

   199 

   200 class CDHCPRelease : public CDHCPState

   201 	{

   202 public:

   203 	CDHCPRelease(CDHCPStateMachine& aDHCP) :

   204 		CDHCPState(aDHCP)

   205 		{

   206 		}

   207 	//create msg sends it off

   208 	virtual CAsynchEvent* ProcessL(TRequestStatus& aStatus);

   209 	};

   210 

   211 

   212 

   213 class CDHCPDecline : public CDHCPState

   214 	{

   215 public:

   216 	CDHCPDecline(CDHCPStateMachine& aDHCP) :

   217 		CDHCPState(aDHCP)

   218 		{

   219 		}

   220 	//create msg sends it off

   221 	virtual CAsynchEvent* ProcessL(TRequestStatus& aStatus);

   222 	};

   223 

   224 #ifdef SYMBIAN_NETWORKING_DHCPSERVER

   225 class CDHCPWaitForClientMsgs : public CDHCPState

   226 	{

   227 public:

   228 	CDHCPWaitForClientMsgs(CDHCPStateMachine& aDHCP) :

   229 		CDHCPState(aDHCP)

   230 		{

   231 		}

   232 	//create msg sends it off

   233 	virtual CAsynchEvent* ProcessL(TRequestStatus& aStatus);

   234 	};

   235 	

   236 class CDHCPHandleClientMsgs : public CDHCPState

   237 	{

   238 public:

   239 	CDHCPHandleClientMsgs(CDHCPStateMachine& aDHCP) :

   240 		CDHCPState(aDHCP)

   241 		{

   242 		}

   243 	//create msg sends it off

   244 	virtual CAsynchEvent* ProcessL(TRequestStatus& aStatus);

   245 	};	

   246 

   247 class CDHCPHandleDiscover : public CDHCPState

   248 	{

   249 public:

   250 	CDHCPHandleDiscover(CDHCPStateMachine& aDHCP) :

   251 		CDHCPState(aDHCP)

   252 		{

   253 		}

   254 	//create msg sends it off

   255 	virtual CAsynchEvent* ProcessL(TRequestStatus& aStatus);

   256 	};

   257 	

   258 class CDHCPProvideOffer : public CDHCPState

   259 	{

   260 public:

   261 	CDHCPProvideOffer(CDHCPStateMachine& aDHCP) :

   262 		CDHCPState(aDHCP)

   263 		{

   264 		}

   265 	//create msg sends it off

   266 	virtual CAsynchEvent* ProcessL(TRequestStatus& aStatus);

   267 	};

   268 	

   269 class CDHCPSendRequestResponse : public CDHCPState

   270 	{

   271 public:

   272 	CDHCPSendRequestResponse(CDHCPStateMachine& aDHCP) :

   273 		CDHCPState(aDHCP)

   274 		{

   275 		}

   276 	//create msg sends it off

   277 	virtual CAsynchEvent* ProcessL(TRequestStatus& aStatus);

   278 	};

   279 	

   280 	

   281 class CDHCPSendInformResponse : public CDHCPState

   282 	{

   283 public:

   284 	CDHCPSendInformResponse(CDHCPStateMachine& aDHCP) :

   285 		CDHCPState(aDHCP)

   286 		{

   287 		}

   288 	//create msg sends it off

   289 	virtual CAsynchEvent* ProcessL(TRequestStatus& aStatus);

   290 	};						

   291 

   292 class CDHCPHandleDecline : public CDHCPState

   293 	{

   294 public:

   295 	CDHCPHandleDecline(CDHCPStateMachine& aDHCP) :

   296 		CDHCPState(aDHCP)

   297 		{

   298 		}

   299 	//create msg sends it off

   300 	virtual CAsynchEvent* ProcessL(TRequestStatus& aStatus);

   301 	};						

   302 	

   303 class CDHCPHandleRelease : public CDHCPState

   304 	{

   305 public:

   306 	CDHCPHandleRelease(CDHCPStateMachine& aDHCP) :

   307 		CDHCPState(aDHCP)

   308 		{

   309 		}

   310 	//create msg sends it off

   311 	virtual CAsynchEvent* ProcessL(TRequestStatus& aStatus);

   312 	};						

   313 	

   314 // To implement a timer for server socket to bind with server IP address	

   315 class CDHCPBindServer : public CDHCPState, public MExpireTimer

   316 	{

   317 public:

   318 	CDHCPBindServer(CDHCPStateMachine& aDHCP) :

   319 		CDHCPState(aDHCP)

   320 		{

   321 		}

   322 	virtual void TimerExpired();

   323 

   324 	//starts bind timer

   325 	virtual CAsynchEvent* ProcessL(TRequestStatus& aStatus);

   326 	

   327 	virtual void Cancel();

   328 protected:

   329 	TInt iErr;

   330 	};	

   331 	

   332 #endif // SYMBIAN_NETWORKING_DHCPSERVER

   333 	

   334 #endif