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 // loop6.cpp - loopback interface for IPv6

    15 //

    16 

    17 #include "in_fmly.h"

    18 #include "loop6.h"

    19 #include <in6_if.h>	// KSoIf*

    20 #include "networkinfo.h"

    21 

    22 CIfLoop6::CIfLoop6()

    23 {

    24 	__DECLARE_NAME(_S("CIfLoop6"));

    25 }

    26 

    27 void CIfLoop6::ConstructL(const TDesC& aTag)

    28 {

    29 	iIfaceName = aTag.AllocL();

    30 	iIfaceMTU = 4096;

    31 

    32 	TCallBack scb(SendCallBack, this);

    33 	iSendCallBack = new(ELeave) CAsyncCallBack(scb, KInet6DefaultPriority);

    34 

    35 	TCallBack rcb(RecvCallBack, this);

    36 	iRecvCallBack = new(ELeave) CAsyncCallBack(rcb, KInet6DefaultPriority);

    37 }

    38 

    39 CIfLoop6::~CIfLoop6()

    40 {

    41 	iRecvQ.Free();

    42 	iSendQ.Free();

    43 

    44 	delete iRecvCallBack;

    45 	delete iSendCallBack;

    46 	delete iIfaceName;

    47 }

    48 

    49 CIfLoop6* CIfLoop6::NewL(const TDesC& aTag)

    50 {

    51 	CIfLoop6* p = new(ELeave) CIfLoop6;

    52 

    53 	CleanupStack::PushL(p);

    54 	p->ConstructL(aTag);

    55 	CleanupStack::Pop();

    56 

    57 	return p;

    58 }

    59 

    60 void CIfLoop6::BindL(TAny* aId)

    61 {

    62 	iNetwork = (CProtocolBase*)aId;

    63 	iNetwork->StartSending((CProtocolBase *)this);

    64 }

    65 

    66 TInt CIfLoop6::State()

    67 {

    68 	return EIfUp;

    69 }

    70 

    71 TInt CIfLoop6::Control(TUint aLevel, TUint aName, TDes8& aOption, TAny*)

    72 	{

    73 	if (aLevel == KSOLInterface)

    74 		{

    75 		switch (aName)

    76 			{

    77 			case KSoIfInfo6:

    78 				{

    79 				__ASSERT_DEBUG(STATIC_CAST(TUint, aOption.MaxLength()) >= sizeof (TSoIfInfo6), User::Panic(_L("LOOP6"), 0));

    80 

    81 				if (STATIC_CAST(TUint, aOption.MaxLength()) < sizeof (TSoIfInfo6))

    82 					return KErrArgument;

    83 

    84 				TSoIfInfo6& opt = *(TSoIfInfo6*)aOption.Ptr();

    85 				opt.iRMtu = iIfaceMTU;

    86 				}

    87 				// FALL THROUGH AS TSoIfInfo6 IS AN EXTENSION OF TSoIfInfo

    88 

    89 			case KSoIfInfo:

    90 				{

    91 				__ASSERT_DEBUG(STATIC_CAST(TUint, aOption.MaxLength()) >= sizeof (TSoIfInfo), User::Panic(_L("LOOP6"), 0));

    92 

    93 				if (STATIC_CAST(TUint, aOption.MaxLength()) < sizeof (TSoIfInfo))

    94 					return KErrArgument;

    95 

    96 				TSoIfInfo& opt = *(TSoIfInfo*)aOption.Ptr();

    97 	

    98 				opt.iFeatures = KIfIsLoopback | KIfCanMulticast;

    99 				opt.iMtu = iIfaceMTU;

   100 				opt.iSpeedMetric = 30000;

   101 				opt.iName = *iIfaceName;

   102 

   103 				return KErrNone;

   104 				}

   105 

   106 

   107 			case KSoIfConfig:

   108 				// PS: If KSoIfConfig returns KErrNotSupported, Update6 does not proceed

   109 				// with setting routes, etc.

   110 				{

   111 				  TSoInet6IfConfig& cfg = *(TSoInet6IfConfig*)aOption.Ptr();	

   112 				  if (!iIfaceName->Compare(_L("loop6")) && cfg.iFamily == KAfInet6)

   113 				    {

   114 				    

   115 				      TSockAddr unspec(KAFUnspec);

   116 				      cfg.iLocalId = unspec;

   117 				      cfg.iRemoteId = unspec;

   118 				      return KErrNone;

   119 				    }

   120 				}

   121 				break;

   122 			case KSoIfGetConnectionInfo:

   123 				{

   124 				if (STATIC_CAST(TUint, aOption.MaxLength()) < sizeof(TSoIfConnectionInfo))

   125 					return KErrArgument;

   126 				TSoIfConnectionInfo &opt = *(TSoIfConnectionInfo *)aOption.Ptr();

   127 				opt.iIAPId = 0;

   128 				opt.iNetworkId = 0;

   129 				return KErrNone;

   130 				}

   131 

   132 			default:

   133 				break;

   134 			}

   135 		}

   136 	return KErrNotSupported;

   137 }

   138 

   139 void CIfLoop6::Info(TNifIfInfo& aInfo) const

   140 {

   141 	aInfo.iVersion = TVersion(KInet6MajorVersionNumber, KInet6MinorVersionNumber, KInet6BuildVersionNumber);

   142 	aInfo.iFlags = KNifIfIsBase | KNifIfCreatedAlone;

   143 	aInfo.iName = *iIfaceName;

   144 	aInfo.iProtocolSupported = KProtocolInet6Ip;

   145 }

   146 

   147 TInt CIfLoop6::Send(RMBufChain &aPacket, TAny*)

   148 {

   149 	iSendQ.Append(aPacket);

   150 	iSendCallBack->CallBack();

   151 

   152 	return 1;

   153 }

   154 

   155 TInt CIfLoop6::RecvCallBack(TAny* aCProtocol)

   156 {

   157 	((CIfLoop6*)aCProtocol)->DoProcess();

   158 

   159 	return 0;

   160 }

   161 

   162 TInt CIfLoop6::SendCallBack(TAny* aCProtocol)

   163 {

   164 	((CIfLoop6*)aCProtocol)->DoSend();

   165 

   166 	return 0;

   167 }

   168 

   169 void CIfLoop6::DoSend()

   170 {

   171 	RMBufPacket send;

   172 	RMBufPacket recv;

   173 

   174 	while (iSendQ.Remove(send))

   175 	{

   176 		send.Unpack();

   177 		Loop(send, recv);

   178 		iRecvQ.Append(recv);

   179 		iRecvCallBack->CallBack();

   180 		send.Free();

   181 	}

   182 }

   183 

   184 void CIfLoop6::DoProcess()

   185 {

   186 	RMBufPacket packet;

   187 

   188 	while (iRecvQ.Remove(packet))

   189 	{

   190 		iNetwork->Process(packet, (CProtocolBase*)this);

   191 	}

   192 }

   193 			

   194 void CIfLoop6::Loop(RMBufPacket& aSend, RMBufPacket& aRecv)

   195 {

   196 	RMBufPktInfo* info = aSend.Info();

   197 

   198 	info->iProtocol = KProtocolInet6Loop;

   199 

   200 	aSend.SetInfo(NULL);

   201 	aRecv.Assign(aSend);

   202 	aRecv.SetInfo(info);

   203 	aRecv.Pack();

   204 }