userlibandfileserver/fileserver/sfile/sf_ext.cpp
changeset 0 a41df078684a
child 87 2f92ad2dc5db
equal deleted inserted replaced
-1:000000000000 0:a41df078684a
       
     1 // Copyright (c) 2002-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 the License "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 // f32\sfile\sf_ext.cpp
       
    15 // 
       
    16 //
       
    17 
       
    18 
       
    19 #include "sf_std.h"
       
    20 
       
    21 typedef CProxyDriveFactory*(*TExtensionNew)();
       
    22 typedef CExtProxyDriveFactory*(*TProxyDriveNew)();
       
    23 
       
    24 
       
    25 /**
       
    26 Constructor.
       
    27 
       
    28 Initialises drive extension count to zero.
       
    29 */
       
    30 TDriveExtInfo::TDriveExtInfo(){iCount=0;}
       
    31 
       
    32 
       
    33 /**
       
    34 Constructor.
       
    35 
       
    36 Note that the class is intended only as an abstract base for other classes.
       
    37 
       
    38 @panic FSERV 51 if the supplied CMountCB pointer is NULL.
       
    39 */
       
    40 CProxyDrive::CProxyDrive(CMountCB* aMount)
       
    41 :iMount(aMount)
       
    42 	{
       
    43 //	__ASSERT_DEBUG(iMount!=NULL,Fault(EProxyDriveConstruction));
       
    44 	}
       
    45 
       
    46 
       
    47 /**
       
    48 Destructor.
       
    49 
       
    50 Frees resources before destruction of the object.
       
    51 */
       
    52 CProxyDrive::~CProxyDrive()
       
    53 	{
       
    54 	
       
    55 	}
       
    56 
       
    57 
       
    58 /**
       
    59 An interface with which control commands can be passed to 
       
    60 the appropriate driver layer.
       
    61 
       
    62 This base implementation performs no operations.
       
    63 
       
    64 @param aMessage Message to be sent.
       
    65 @param aCommand Command type.
       
    66 @param aParam1  1st parameter of control message.
       
    67 @param aParam2  2nd parameter of control message.
       
    68 
       
    69 @return KErrNone
       
    70 */
       
    71 EXPORT_C TInt CProxyDrive::ControlIO(const RMessagePtr2& /*aMessage*/,TInt /*aCommand*/,TAny* /*aParam1*/,TAny* /*aParam2*/)
       
    72 //
       
    73 // General purpose function for use by specific file systems and extensions
       
    74 //
       
    75 	{
       
    76 	return(KErrNone);
       
    77 	}
       
    78 
       
    79 /**
       
    80 General purpose read function for use by specific file systems and extensions.
       
    81 
       
    82 This base implementation performs no operations.
       
    83 
       
    84 @param aPos    The address from where the read begins.
       
    85 @param aLength The length of the read.
       
    86 @param aTrg    A descriptor of the memory buffer from which to read.
       
    87 @param aThreadHandle The handle-number representing the drive thread.
       
    88 @param aOffset Offset into aTrg to read the data from.
       
    89 @param aFlags  Flags to be passed into the driver.
       
    90 
       
    91 @return KErrNone
       
    92 */
       
    93 EXPORT_C TInt CProxyDrive::Read(TInt64 /*aPos*/,TInt /*aLength*/,const TAny* /*aTrg*/,TInt /*aThreadHandle*/,TInt /*aOffset*/, TInt /*aFlags*/)
       
    94 	{
       
    95 	return(KErrNone);
       
    96 	}
       
    97 
       
    98 /**
       
    99 General purpose write function for use by specific file systems and extensions.
       
   100 
       
   101 This base implementation performs no operations.
       
   102 
       
   103 @param aPos    The address from where the write begins.
       
   104 @param aLength The length of the write.
       
   105 @param aSrc    A descriptor of the memory buffer from which to write.
       
   106 @param aThreadHandle The handle-number representing the drive thread.
       
   107 @param aOffset Offset into aSrc to write the data to.
       
   108 @param aFlags  Flags to be passed into the driver.
       
   109 
       
   110 @return KErrNone
       
   111 */
       
   112 EXPORT_C TInt CProxyDrive::Write(TInt64 /*aPos*/,TInt /*aLength*/,const TAny* /*aSrc*/,TInt /*aThreadHandle*/,TInt /*aOffset*/, TInt /*aFlags*/)
       
   113 	{
       
   114 	return(KErrNone);
       
   115 	}
       
   116 
       
   117 
       
   118 /**
       
   119 Issue a notification that a physical delete has occurred. 
       
   120 For example a cluster or partition has been freed.
       
   121 
       
   122 This base implementation performs no operations.
       
   123 
       
   124 @param aPos    The position of the data which is being deleted.
       
   125 @param aLength The length of the data which is being deleted.
       
   126 
       
   127 @return KErrNone
       
   128 */
       
   129 EXPORT_C TInt CProxyDrive::DeleteNotify(TInt64 /*aPos*/, TInt /*aLength*/)
       
   130 	{
       
   131 	return(KErrNone);
       
   132 	}
       
   133 	
       
   134 /**
       
   135 An interface with which information can be retrieved about disk errors.
       
   136 
       
   137 This base implementation performs no operations.
       
   138 
       
   139 @param aErrorInfo Reference to a descriptor containing disk error information.
       
   140 
       
   141 @return KErrNone
       
   142 */	
       
   143 EXPORT_C TInt CProxyDrive::GetLastErrorInfo(TDes8& /*aErrorInfo*/)
       
   144 	{
       
   145 	return(KErrNotSupported);
       
   146 	}
       
   147 	
       
   148 EXPORT_C TInt CProxyDrive::GetLocalDrive(TBusLocalDrive*& aLocDrv)
       
   149 	{
       
   150 	return (GetInterface(EGetLocalDrive, (TAny*&)aLocDrv, (TAny*)this));	// this GetInterface does the dirty work for you...
       
   151 	}
       
   152 
       
   153 EXPORT_C TInt CProxyDrive::Finalise(TBool aIsFinalised)
       
   154 	{
       
   155 	TAny* dummyInterface;
       
   156 	return (GetInterface(EFinalised, dummyInterface, (TAny*)aIsFinalised));
       
   157 	}
       
   158 
       
   159 
       
   160 /**
       
   161 Called to get a Proxy drive interface.
       
   162 
       
   163 @param aInterfaceId Interface identifier of the interface to be retrieved.
       
   164 @param aInterface Address of variable that retrieves the specified interface.
       
   165 @param aInput Data required for the instantiation of the interface.
       
   166 
       
   167 This base implementation performs no operations.
       
   168 
       
   169 @return KErrNotSupported
       
   170 */	
       
   171 EXPORT_C TInt CProxyDrive::GetInterface(TInt /*aInterfaceId*/,TAny*& /*aInterface*/,TAny* /*aInput*/)
       
   172 	{
       
   173 	return(KErrNotSupported);
       
   174 	}	
       
   175 
       
   176 
       
   177 /**
       
   178 Constructor.
       
   179 */
       
   180 EXPORT_C CLocDrvMountCB::CLocDrvMountCB() {}
       
   181 
       
   182 
       
   183 /**
       
   184 Destructor.
       
   185 
       
   186 Frees assigned Proxy drive before destruction of the object.
       
   187 */
       
   188 EXPORT_C CLocDrvMountCB::~CLocDrvMountCB()
       
   189 	{
       
   190 	__PRINT1(_L("CLocDrvMountCB::~CLocDrvMountCB() 0x%x"),this);
       
   191 	if(iProxyDrive && !LocalDrives::IsProxyDrive(Drive().DriveNumber()) && LocalDrives::IsValidDriveMapping(Drive().DriveNumber()))
       
   192 		delete(iProxyDrive);
       
   193 	}
       
   194 
       
   195 
       
   196 /**
       
   197 Creates and initialises the local drive.
       
   198 
       
   199 @param aLocDrv The local drive to be created
       
   200 
       
   201 @return System wide error code.
       
   202 */		
       
   203 EXPORT_C TInt CLocDrvMountCB::CreateLocalDrive(TBusLocalDrive& aLocDrv)
       
   204 	{
       
   205 	__PRINT(_L("CLocDrvMountCB::CreateLocalDrive()"));
       
   206 	if(iProxyDrive!=NULL)
       
   207 		return(KErrNone);
       
   208 	TInt r;
       
   209 	CProxyDrive* pConcrete=CLocalProxyDrive::New(this,aLocDrv);
       
   210 	if(pConcrete==NULL)
       
   211 		{
       
   212 		r=KErrNoMemory;
       
   213 		}
       
   214 	else
       
   215 		{
       
   216 		// if failure then pConcrete will be deleted by CreateProxyDriveL()
       
   217 		TRAP(r,iProxyDrive=CreateProxyDriveL(pConcrete,this));	
       
   218 		}
       
   219 	if(r==KErrNone)
       
   220 		r=InitLocalDrive();
       
   221 	__PRINT1(_L("CreateLocalDrive r=%d"),r);
       
   222 	return(r);
       
   223 	}
       
   224 
       
   225 EXPORT_C TInt CLocDrvMountCB::CreateDrive(TInt aDriveNumber)
       
   226 /** Create drive
       
   227 	Ascertain if the drive is mapped to a local drive or a proxy drive, and create the drive
       
   228 	as appropriate
       
   229 	@param aDriveNumer drive number
       
   230 	@return KErrNone on success
       
   231 		     KErrArgument is the drive is not mapped to a proxy or a local drive or if the number
       
   232 		     is invalid
       
   233 */
       
   234 	{
       
   235 	// dunno why we are using TInts instead of TUints here
       
   236 	__PRINT(_L("CLocDrvMountCB::CreateLocalDrive()"));
       
   237 
       
   238 	if (aDriveNumber<0 || aDriveNumber>=KMaxDrives) return KErrArgument;
       
   239 	TInt r = KErrNone;
       
   240 	TInt aDriveLocal = LocalDrives::DriveNumberToLocalDriveNumber(aDriveNumber);
       
   241 	if (aDriveLocal == KDriveInvalid) return KErrArgument;
       
   242 	if (aDriveLocal < KMaxLocalDrives)
       
   243 		{
       
   244 		return CreateLocalDrive(LocalDrives::GetLocalDrive(aDriveNumber));	// drive is really local
       
   245 		}
       
   246 	else
       
   247 		{
       
   248 		CExtProxyDrive* pProxyDrive = LocalDrives::GetProxyDrive(aDriveNumber);
       
   249 		__ASSERT_ALWAYS(pProxyDrive != NULL,User::Panic(_L("CreateDrive - pProxyDrive == NULL"), -999));
       
   250 
       
   251 		iProxyDrive = CreateProxyDriveL(pProxyDrive, this);
       
   252 		__ASSERT_ALWAYS(iProxyDrive != NULL,User::Panic(_L("CreateDrive - CreateProxyDrive returned NULL"), -999));
       
   253 
       
   254 		r = InitLocalDrive();
       
   255 		}
       
   256 	
       
   257 	return r;
       
   258 	}
       
   259 
       
   260 
       
   261 /**
       
   262 Initialise the local drive
       
   263 
       
   264 @panic FSERV 52 if initialise when no local drive exists.
       
   265 
       
   266 @return system wide error code
       
   267 */
       
   268 EXPORT_C TInt CLocDrvMountCB::InitLocalDrive()
       
   269 	{
       
   270 	__ASSERT_ALWAYS(iProxyDrive!=NULL,Fault(ELocDrvInitLocalDrive));
       
   271 	iProxyDrive->SetMount(this);
       
   272 	return(iProxyDrive->Initialise());
       
   273 	}
       
   274 
       
   275 /**
       
   276 Dismount the local drive
       
   277 
       
   278 @panic FSERV 53 if dismount when no local drive exists.
       
   279 */
       
   280 EXPORT_C void CLocDrvMountCB::DismountedLocalDrive()
       
   281 	{
       
   282 	__ASSERT_ALWAYS(iProxyDrive!=NULL,Fault(ELocDrvDismountedLocalDrive));
       
   283 	iProxyDrive->Dismounted();
       
   284 	iProxyDrive->SetMount(NULL);
       
   285 	}
       
   286 
       
   287 
       
   288 /**
       
   289 static constructor.
       
   290 
       
   291 Instatiates a CLocalProxyDrive objects with the given arguments.
       
   292 
       
   293 @param aMount The mount control block
       
   294 @param aLocDrv The local drive.
       
   295 
       
   296 @return pointer to instantiated CLocalProxyDrive object.
       
   297 */
       
   298 CLocalProxyDrive* CLocalProxyDrive::New(CMountCB* aMount,TBusLocalDrive& aLocDrv)
       
   299 	{
       
   300 	TRACE2(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveNew, EF32TraceUidProxyDrive, 
       
   301 		aMount, aMount->DriveNumber());
       
   302 
       
   303 	CLocalProxyDrive* proxyDrive = new CLocalProxyDrive(aMount,aLocDrv);
       
   304 	
       
   305 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveNewRet, EF32TraceUidProxyDrive, proxyDrive);
       
   306 	return proxyDrive;
       
   307 	}
       
   308 
       
   309 /**
       
   310 Constructor.
       
   311 
       
   312 @param aMount The mount control block.
       
   313 @param aLocDrv The local drive.
       
   314 */
       
   315 CLocalProxyDrive::CLocalProxyDrive(CMountCB* aMount,TBusLocalDrive& aLocDrv)
       
   316 :CProxyDrive(aMount),iLocDrv(aLocDrv)
       
   317 	{
       
   318 	__PRINT(_L("CLocalProxyDrive::CLocalProxyDrive()"));
       
   319 	}
       
   320 
       
   321 
       
   322 /**
       
   323 Initialise the connected drive.
       
   324 
       
   325 This implementation performs no operations.
       
   326 
       
   327 @return KErrNone.
       
   328 */
       
   329 TInt CLocalProxyDrive::Initialise()
       
   330 	{
       
   331 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveInitialise, EF32TraceUidProxyDrive, this);
       
   332 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveInitialiseRet, EF32TraceUidProxyDrive, KErrNone);
       
   333 
       
   334 	return(KErrNone);
       
   335 	}
       
   336 
       
   337 
       
   338 /**
       
   339 Ensures any cached data is flushed before unmounting drive.
       
   340 
       
   341 This implementation performs no operations.
       
   342 
       
   343 @return KErrNone.
       
   344 */
       
   345 TInt CLocalProxyDrive::Dismounted()
       
   346 	{
       
   347 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveDismounted, EF32TraceUidProxyDrive, this);
       
   348 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveDismountedRet, EF32TraceUidProxyDrive, KErrNone);
       
   349 
       
   350 	return(KErrNone);
       
   351 	}
       
   352 
       
   353 
       
   354 /**
       
   355 Increase the size of the connected drive by the specified length (in bytes).
       
   356 
       
   357 @param aLength The length/size (in bytes) by which the drive is to be increased.
       
   358 
       
   359 @return system wide error code.
       
   360 */
       
   361 TInt CLocalProxyDrive::Enlarge(TInt aLength)
       
   362 	{
       
   363 	TRACE2(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveEnlarge, EF32TraceUidProxyDrive, this, aLength);
       
   364 
       
   365 	TInt r = iLocDrv.Enlarge(aLength);
       
   366 
       
   367 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveEnlargeRet, EF32TraceUidProxyDrive, r);
       
   368 	return r;
       
   369 	}
       
   370 
       
   371 
       
   372 /**
       
   373 Reduce the size of the connected drive by removing the specified length
       
   374 (in bytes) starting at the specified position.
       
   375 Refer to relevant media driver documentation for implementation/restriction 
       
   376 notes.
       
   377 
       
   378 @param aPos    The start position of area to be removed.
       
   379 @param aLength The length of the data which is being removed.
       
   380 
       
   381 @return system wide error code.
       
   382 */
       
   383 TInt CLocalProxyDrive::ReduceSize(TInt aPos, TInt aLength)
       
   384 	{
       
   385 	TRACE3(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveReduceSize, EF32TraceUidProxyDrive, this, aPos, aLength);
       
   386 
       
   387 	TInt r = iLocDrv.ReduceSize(aPos,aLength);
       
   388 
       
   389 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveReduceSizeRet, EF32TraceUidProxyDrive, r);
       
   390 	return r;
       
   391 	}
       
   392 
       
   393 
       
   394 /**
       
   395 Read from the connected drive, and pass flags to driver.
       
   396 
       
   397 @param aPos    The address from where the read begins.
       
   398 @param aLength The length of the read.
       
   399 @param aTrg    A descriptor of the memory buffer from which to read.
       
   400 @param aThreadHandle The handle-number representing the drive thread.
       
   401 @param aOffset Offset into aTrg to read the data from.
       
   402 @param aFlags  Flags to be passed into the driver.
       
   403 
       
   404 @return system wide error code.
       
   405 */
       
   406 TInt CLocalProxyDrive::Read(TInt64 aPos,TInt aLength,const TAny* aTrg,TInt aThreadHandle,TInt aOffset, TInt aFlags)
       
   407 	{
       
   408 	TRACETHREADIDH(aThreadHandle);
       
   409 	TRACE8(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveRead1, EF32TraceUidProxyDrive, 
       
   410 		this, I64LOW(aPos), I64HIGH(aPos), aLength, aTrg, threadId, aOffset, aFlags);
       
   411 
       
   412 	TInt r = iLocDrv.Read(aPos,aLength,aTrg,aThreadHandle,aOffset,aFlags);
       
   413 
       
   414 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveRead1Ret, EF32TraceUidProxyDrive, r);
       
   415 	return r;
       
   416 	}
       
   417 
       
   418 /**
       
   419 Read from the connected drive.
       
   420 
       
   421 @param aPos    The address from where the read begins.
       
   422 @param aLength The length of the read.
       
   423 @param aTrg    A descriptor of the memory buffer from which to read.
       
   424 @param aThreadHandle The handle-number representing the drive thread.
       
   425 @param aOffset Offset into aTrg to read the data from.
       
   426 
       
   427 @return system wide error code.
       
   428 */
       
   429 TInt CLocalProxyDrive::Read(TInt64 aPos,TInt aLength,const TAny* aTrg,TInt aThreadHandle,TInt anOffset)
       
   430 	{
       
   431 	TRACETHREADIDH(aThreadHandle);
       
   432 	TRACE7(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveRead2, EF32TraceUidProxyDrive, 
       
   433 		this, I64LOW(aPos), I64HIGH(aPos), aLength, aTrg, threadId, anOffset);
       
   434 
       
   435 	TInt r = iLocDrv.Read(aPos,aLength,aTrg,aThreadHandle,anOffset);
       
   436 
       
   437 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveRead2Ret, EF32TraceUidProxyDrive, r);
       
   438 	return r;
       
   439 	}
       
   440 
       
   441 /**
       
   442 Read from the connected drive.
       
   443 
       
   444 @param aPos    The address from where the read begins.
       
   445 @param aLength The length of the read.
       
   446 @param aTrg    A descriptor of the memory buffer from which to read.
       
   447 
       
   448 @return system wide error code.
       
   449 */
       
   450 TInt CLocalProxyDrive::Read(TInt64 aPos,TInt aLength,TDes8& aTrg)
       
   451 	{
       
   452 	TRACE5(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveRead3, EF32TraceUidProxyDrive, 
       
   453 		this, I64LOW(aPos), I64HIGH(aPos), aLength, &aTrg);
       
   454 
       
   455 	TInt r = iLocDrv.Read(aPos,aLength,aTrg);
       
   456 
       
   457 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveRead3Ret, EF32TraceUidProxyDrive, r);
       
   458 	return r;
       
   459 	}
       
   460 
       
   461 
       
   462 /**
       
   463 Write to the connected drive and pass flags to driver.
       
   464 
       
   465 @param aPos    The address from where the write begins.
       
   466 @param aLength The length of the write.
       
   467 @param aSrc    A descriptor of the memory buffer from which to write.
       
   468 @param aThreadHandle The handle-number representing the drive thread.
       
   469 @param aOffset Offset into aSrc to write the data to.
       
   470 @param aFlags  Flags to be passed into the driver.
       
   471 
       
   472 @return system wide error code.
       
   473 */
       
   474 TInt CLocalProxyDrive::Write(TInt64 aPos,TInt aLength,const TAny* aSrc,TInt aThreadHandle,TInt aOffset,TInt aFlags)
       
   475 	{
       
   476 	TRACETHREADIDH(aThreadHandle);
       
   477 	TRACE8(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveWrite1, EF32TraceUidProxyDrive, 
       
   478 		this, I64LOW(aPos), I64HIGH(aPos), aLength, aSrc, threadId, aOffset, aFlags);
       
   479 
       
   480 	TInt r = iLocDrv.Write(aPos,aLength,aSrc,aThreadHandle,aOffset,aFlags);
       
   481 
       
   482 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveWrite1Ret, EF32TraceUidProxyDrive, r);
       
   483 
       
   484 	return r;
       
   485 	}
       
   486 
       
   487 
       
   488 /**
       
   489 Write to the connected drive.
       
   490 
       
   491 @param aPos    The address from where the write begins.
       
   492 @param aLength The length of the write.
       
   493 @param aSrc    A descriptor of the memory buffer from which to write.
       
   494 @param aThreadHandle The handle-number representing the drive thread.
       
   495 @param aOffset Offset into aSrc to write the data to.
       
   496 
       
   497 @return system wide error code.
       
   498 */
       
   499 TInt CLocalProxyDrive::Write(TInt64 aPos,TInt aLength,const TAny* aSrc,TInt aThreadHandle,TInt anOffset)
       
   500 	{
       
   501 	TRACETHREADIDH(aThreadHandle);
       
   502 	TRACE7(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveWrite2, EF32TraceUidProxyDrive, 
       
   503 		this, I64LOW(aPos), I64HIGH(aPos), aLength, aSrc, threadId, anOffset);
       
   504 
       
   505 	TInt r = iLocDrv.Write(aPos,aLength,aSrc,aThreadHandle,anOffset);
       
   506 
       
   507 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveWrite2Ret, EF32TraceUidProxyDrive, r);
       
   508 	return r;
       
   509 	}
       
   510 
       
   511 
       
   512 /**
       
   513 Write to the connected drive.
       
   514 
       
   515 @param aPos    The address from where the write begins.
       
   516 @param aSrc    A descriptor of the memory buffer from which to write.
       
   517 
       
   518 @return system wide error code.
       
   519 */
       
   520 TInt CLocalProxyDrive::Write(TInt64 aPos,const TDesC8& aSrc)
       
   521 	{
       
   522 	TRACE5(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveWrite3, EF32TraceUidProxyDrive, 
       
   523 		this, I64LOW(aPos), I64HIGH(aPos), aSrc.Length(), &aSrc);
       
   524 
       
   525 	TInt r = iLocDrv.Write(aPos,aSrc);
       
   526 
       
   527 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveWrite3Ret, EF32TraceUidProxyDrive, r);
       
   528 	return r;
       
   529 	}
       
   530 	
       
   531 	
       
   532 /**
       
   533 Get the connected drive's capabilities information.
       
   534 
       
   535 @param anInfo A descriptor of the connected drives capabilities.
       
   536 
       
   537 @return system wide error code
       
   538 */
       
   539 TInt CLocalProxyDrive::Caps(TDes8& anInfo)
       
   540 	{
       
   541 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveCaps, EF32TraceUidProxyDrive, this);
       
   542 
       
   543 	TInt r = iLocDrv.Caps(anInfo);
       
   544 
       
   545 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveCapsRet, EF32TraceUidProxyDrive, r);
       
   546 	return r;
       
   547 	}
       
   548 
       
   549 
       
   550 /**
       
   551 Format the connected drive.
       
   552 
       
   553 @param anInfo Device specific format information.
       
   554 
       
   555 @return system wide error code.
       
   556 */
       
   557 TInt CLocalProxyDrive::Format(TFormatInfo& anInfo)
       
   558 	{
       
   559 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveFormat1, EF32TraceUidProxyDrive, this);
       
   560 
       
   561 	TInt r = iLocDrv.Format(anInfo);
       
   562 
       
   563 	TRACE4(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveFormat1Ret, EF32TraceUidProxyDrive, 
       
   564 		r, anInfo.iFormatIsCurrent, anInfo.i512ByteSectorsFormatted, anInfo.iMaxBytesPerFormat);
       
   565 	return r;
       
   566 	}
       
   567 
       
   568 
       
   569 /**
       
   570 Format the connected drive.
       
   571 
       
   572 @param aPos    The position of the data which is being formatted.
       
   573 @param aLength The length of the data which is being formatted.
       
   574 
       
   575 @return system wide error code.
       
   576 */
       
   577 TInt CLocalProxyDrive::Format(TInt64 aPos,TInt aLength)
       
   578 	{
       
   579 	TRACE4(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveFormat2, EF32TraceUidProxyDrive, 
       
   580 		this, I64LOW(aPos), I64HIGH(aPos), aLength);
       
   581 
       
   582 	TInt r = iLocDrv.Format(aPos,aLength);
       
   583 
       
   584 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveFormat2Ret, EF32TraceUidProxyDrive, r);
       
   585 	return r;
       
   586 	}
       
   587 
       
   588 
       
   589 /**
       
   590 Set the mount information on the local drive.
       
   591 
       
   592 @param aMountInfo Information passed down to the media driver. The meaning of this information depends on the media driver.
       
   593 @param aMountInfoThreadHandle  Message thread handle number.
       
   594 
       
   595 @return system wide error code.
       
   596 */
       
   597 TInt CLocalProxyDrive::SetMountInfo(const TDesC8* aMountInfo,TInt aMountInfoThreadHandle)
       
   598 	{
       
   599 	TRACE3(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveSetMountInfo, EF32TraceUidProxyDrive, this, aMountInfo, aMountInfoThreadHandle);
       
   600 
       
   601 	TInt r = iLocDrv.SetMountInfo(aMountInfo,aMountInfoThreadHandle);
       
   602 
       
   603 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveSetMountInfoRet, EF32TraceUidProxyDrive, r);
       
   604 	return r;
       
   605 	}
       
   606 
       
   607 
       
   608 /**
       
   609 Forces a remount on the local drive
       
   610 
       
   611 @param aFlags Flags to be passed into the driver.
       
   612 
       
   613 @return system wide error code.
       
   614 */
       
   615 TInt CLocalProxyDrive::ForceRemount(TUint aFlags)
       
   616 	{
       
   617 	TRACE2(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveForceRemount, EF32TraceUidProxyDrive, this, aFlags);
       
   618 
       
   619 	TInt r = iLocDrv.ForceRemount(aFlags);
       
   620 
       
   621 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveForceRemountRet, EF32TraceUidProxyDrive, r);
       
   622 	return r;
       
   623 	}
       
   624 
       
   625 /**
       
   626 An interface with which control commands can be passed to 
       
   627 the appropriate driver layer.
       
   628 
       
   629 @param aMessage Message to be sent.
       
   630 @param aCommand Command type.
       
   631 @param aParam1  1st parameter of control message.
       
   632 @param aParam2  2nd parameter of control message.
       
   633 
       
   634 @return system wide error code.
       
   635 */
       
   636 TInt CLocalProxyDrive::ControlIO(const RMessagePtr2& /*aMessage*/,TInt aCommand,TAny* aParam1,TAny* aParam2)
       
   637 	{
       
   638 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveControlIO, EF32TraceUidProxyDrive, this);
       
   639 
       
   640 	TInt r = iLocDrv.ControlIO(aCommand,aParam1,aParam2);
       
   641 
       
   642 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveControlIORet, EF32TraceUidProxyDrive, r);
       
   643 	return r;
       
   644 	}
       
   645 	
       
   646 	
       
   647 /**
       
   648 Unlocks a password-enabled device.
       
   649 
       
   650 @param aPassword A descriptor containing the existing password.
       
   651 @param aStorePassword If ETrue, the password is added to the password store.
       
   652 
       
   653 @return system wide error code.
       
   654 */
       
   655 TInt CLocalProxyDrive::Unlock(TMediaPassword &aPassword, TBool aStorePassword)
       
   656 	{
       
   657 	TRACE2(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveUnlock, EF32TraceUidProxyDrive, this, aStorePassword);
       
   658 
       
   659 	TInt r = iLocDrv.Unlock(aPassword,aStorePassword);
       
   660 
       
   661 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveUnlockRet, EF32TraceUidProxyDrive, r);
       
   662 	return r;
       
   663 	}
       
   664 
       
   665 
       
   666 /**
       
   667 Locks a password-enabled device with the new password.
       
   668 
       
   669 @param aOldPassword A descriptor containing the existing password.
       
   670 @param aNewPassword A descriptor containing the new password.
       
   671 @param aStorePassword If ETrue, the password is added to the password store.
       
   672 
       
   673 @return system wide error code.
       
   674 */
       
   675 TInt CLocalProxyDrive::Lock(TMediaPassword &aOldPassword, TMediaPassword &aNewPassword, TBool aStorePassword)
       
   676 	{
       
   677 	TRACE2(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveLock, EF32TraceUidProxyDrive, this, aStorePassword);
       
   678 
       
   679 	TInt r = iLocDrv.SetPassword(aOldPassword,aNewPassword,aStorePassword);
       
   680 
       
   681 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveLockRet, EF32TraceUidProxyDrive, r);
       
   682 	return r;
       
   683 	}
       
   684 
       
   685 
       
   686 /**
       
   687 Clears a password from a device - controller sets password to null.
       
   688 
       
   689 @param aPassword A descriptor containing the password.
       
   690 
       
   691 @return system wide error code.
       
   692 */
       
   693 TInt CLocalProxyDrive::Clear(TMediaPassword &aPassword)
       
   694 	{
       
   695 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveClear, EF32TraceUidProxyDrive, this);
       
   696 
       
   697 	TInt r = iLocDrv.Clear(aPassword);
       
   698 
       
   699 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveClearRet, EF32TraceUidProxyDrive, r);
       
   700 	return r;
       
   701 	}
       
   702 
       
   703 /**
       
   704 Forcibly unlock a password-enabled drive.
       
   705 
       
   706 @return system wide error code.
       
   707 */
       
   708 TInt CLocalProxyDrive::ErasePassword()
       
   709 	{
       
   710 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveErasePassword, EF32TraceUidProxyDrive, this);
       
   711 
       
   712 	TInt r = iLocDrv.ErasePassword();
       
   713 
       
   714 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveErasePasswordRet, EF32TraceUidProxyDrive, r);
       
   715 	return r;
       
   716 	}
       
   717 
       
   718 /**
       
   719 Notify the media driver that an area of the partition has been deleted.
       
   720 Used by some media drivers (e.g. NAND flash) for garbage collection.
       
   721 
       
   722 @param aPos    The position of the data which is being deleted.
       
   723 @param aLength The length of the data which is being deleted.
       
   724 
       
   725 @return System wide error code.
       
   726 */
       
   727 TInt CLocalProxyDrive::DeleteNotify(TInt64 aPos, TInt aLength)
       
   728 	{
       
   729 	TRACE4(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveDeleteNotify, EF32TraceUidProxyDrive, 
       
   730 		this, I64LOW(aPos), I64HIGH(aPos), aLength);
       
   731 
       
   732 	TInt r = iLocDrv.DeleteNotify(aPos, aLength);
       
   733 
       
   734 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveDeleteNotifyRet, EF32TraceUidProxyDrive, r);
       
   735 	return r;
       
   736 	}
       
   737 
       
   738 
       
   739 /**
       
   740 Retrieve disk error information.
       
   741 
       
   742 @param aErrorInfo Reference to a descriptor containing disk error information.
       
   743 
       
   744 @return System wide error code.
       
   745 */	
       
   746 TInt CLocalProxyDrive::GetLastErrorInfo(TDes8 &aErrorInfo)
       
   747 	{
       
   748 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveGetLastErrorInfo, EF32TraceUidProxyDrive, this);
       
   749 
       
   750 	TInt r = iLocDrv.GetLastErrorInfo(aErrorInfo);
       
   751 
       
   752 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveGetLastErrorInfoRet, EF32TraceUidProxyDrive, r);
       
   753 	return r;
       
   754 	}
       
   755 
       
   756 
       
   757 TInt CLocalProxyDrive::GetInterface(TInt aInterfaceId,TAny*& aInterface,TAny* aInput)
       
   758 	{
       
   759 	TRACE3(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveGetInterface, EF32TraceUidProxyDrive, 
       
   760 		this, aInterfaceId, aInput);
       
   761 
       
   762 	TInt r;
       
   763 	switch(aInterfaceId)
       
   764 		{
       
   765 		case EGetLocalDrive:
       
   766 			__ASSERT_ALWAYS((CProxyDrive*)aInput==this,Fault(ELocDrvInvalidLocalDrive));
       
   767 			(TBusLocalDrive*&)aInterface=&iLocDrv;
       
   768 			r = KErrNone;
       
   769 			break;
       
   770 
       
   771         case ELocalBufferSupport:
       
   772             aInterface = NULL;
       
   773 			r = KErrNone;
       
   774 			break;
       
   775 
       
   776 		default:
       
   777 			r= CProxyDrive::GetInterface(aInterfaceId,aInterface,aInput);
       
   778 		}
       
   779 
       
   780 	TRACERET2(UTF::EBorder, UTraceModuleProxyDrive::ECLocalProxyDriveGetInterfaceRet, EF32TraceUidProxyDrive, r, aInterface);
       
   781 	return r;
       
   782 	}
       
   783 
       
   784 
       
   785 
       
   786 /**
       
   787 Constructor.
       
   788 
       
   789 @panic FSERV 54 if the supplied CMountCB pointer is NULL.
       
   790 */
       
   791 EXPORT_C CBaseExtProxyDrive::CBaseExtProxyDrive(CProxyDrive* aProxyDrive, CMountCB* aMount)
       
   792 :CProxyDrive(aMount),iProxy(aProxyDrive)
       
   793 	{
       
   794 	__ASSERT_DEBUG(iProxy!=NULL,Fault(EBaseExtConstruction));
       
   795 	}	
       
   796 	
       
   797 /**
       
   798 Destructor.
       
   799 
       
   800 Frees resources before destruction of the object.
       
   801 */	
       
   802 EXPORT_C CBaseExtProxyDrive::~CBaseExtProxyDrive()
       
   803 	{
       
   804 	delete(iProxy);
       
   805 	}
       
   806 
       
   807 
       
   808 /**
       
   809 Initialise the proxy drive.
       
   810 
       
   811 This implementation performs no operations.
       
   812 
       
   813 @return system wide error code.
       
   814 */
       
   815 EXPORT_C TInt CBaseExtProxyDrive::Initialise()
       
   816 	{
       
   817 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveInitialise, EF32TraceUidProxyDrive, this);
       
   818 
       
   819 	TInt r = iProxy->Initialise();
       
   820 
       
   821 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveInitialiseRet, EF32TraceUidProxyDrive, r);
       
   822 	return r;
       
   823 	}
       
   824 
       
   825 
       
   826 /**
       
   827 Calls Dismounted() on the proxy drive.
       
   828 
       
   829 @return KErrNone.
       
   830 */
       
   831 EXPORT_C TInt CBaseExtProxyDrive::Dismounted()
       
   832 	{
       
   833 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveDismounted, EF32TraceUidProxyDrive, this);
       
   834 
       
   835 	TInt r = iProxy->Dismounted();
       
   836 
       
   837 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveDismountedRet, EF32TraceUidProxyDrive, r);
       
   838 	return r;
       
   839 	}
       
   840 
       
   841 /**
       
   842 Increase the size of the proxy drive by the specified length (in bytes).
       
   843 
       
   844 @param aLength The length (in bytes) of which the drive is to be increased by.
       
   845 
       
   846 @return system wide error code.
       
   847 */
       
   848 EXPORT_C TInt CBaseExtProxyDrive::Enlarge(TInt aLength)
       
   849 	{
       
   850 	TRACE2(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveEnlarge, EF32TraceUidProxyDrive, this, aLength);
       
   851 
       
   852 	TInt r = iProxy->Enlarge(aLength);
       
   853 
       
   854 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveEnlargeRet, EF32TraceUidProxyDrive, r);
       
   855 	return r;
       
   856 	}
       
   857 
       
   858 
       
   859 /**
       
   860 Reduce the size of the proxy drive by removing the specified length
       
   861 (in bytes) starting at the specified position.
       
   862 Refer to relevant media driver documentation for implementation/restriction 
       
   863 notes.
       
   864 
       
   865 @param aPos    The start position of area to be removed.
       
   866 @param aLength The length/size (in bytes) by which the drive is to be reduced.
       
   867 
       
   868 @return system wide error code.
       
   869 */
       
   870 EXPORT_C TInt CBaseExtProxyDrive::ReduceSize(TInt aPos, TInt aLength)
       
   871 	{
       
   872 	TRACE3(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveReduceSize, EF32TraceUidProxyDrive, this, aPos, aLength);
       
   873 
       
   874 	TInt r = iProxy->ReduceSize(aPos,aLength);
       
   875 
       
   876 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveReduceSizeRet, EF32TraceUidProxyDrive, r);
       
   877 	return r;
       
   878 	}
       
   879 
       
   880 
       
   881 /**
       
   882 Read from the proxy drive, and pass flags to driver.
       
   883 
       
   884 @param aPos    The address from where the read begins.
       
   885 @param aLength The length of the read.
       
   886 @param aTrg    A descriptor of the memory buffer from which to read.
       
   887 @param aThreadHandle The handle-number representing the drive thread.
       
   888 @param aOffset Offset into aTrg to read the data from.
       
   889 @param aFlags  Flags to be passed into the driver.
       
   890 
       
   891 @return system wide error code.
       
   892 */
       
   893 EXPORT_C TInt CBaseExtProxyDrive::Read(TInt64 aPos,TInt aLength,const TAny* aTrg,TInt aThreadHandle,TInt aOffset,TInt aFlags)
       
   894 	{
       
   895 	TRACETHREADIDH(aThreadHandle);
       
   896 	TRACE8(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveRead1, EF32TraceUidProxyDrive, 
       
   897 		this, I64LOW(aPos), I64HIGH(aPos), aLength, aTrg, threadId, aOffset, aFlags);
       
   898 
       
   899 	TInt r = iProxy->Read(aPos,aLength,aTrg,aThreadHandle,aOffset,aFlags);
       
   900 
       
   901 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveRead1Ret, EF32TraceUidProxyDrive, r);
       
   902 
       
   903 	return r;
       
   904 	}
       
   905 
       
   906 
       
   907 /**
       
   908 Read from the proxy drive.
       
   909 
       
   910 @param aPos    The address from where the read begins.
       
   911 @param aLength The length of the read.
       
   912 @param aTrg    A descriptor of the memory buffer from which to read.
       
   913 @param aThreadHandle The handle-number representing the drive thread.
       
   914 @param aOffset Offset into aTrg to read the data from.
       
   915 
       
   916 @return system wide error code.
       
   917 */
       
   918 EXPORT_C TInt CBaseExtProxyDrive::Read(TInt64 aPos,TInt aLength,const TAny* aTrg,TInt aThreadHandle,TInt anOffset)
       
   919 	{
       
   920 	TRACETHREADIDH(aThreadHandle);
       
   921 	TRACE7(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveRead2, EF32TraceUidProxyDrive, 
       
   922 		this, I64LOW(aPos), I64HIGH(aPos), aLength, aTrg, threadId, anOffset);
       
   923 
       
   924 	TInt r = iProxy->Read(aPos,aLength,aTrg,aThreadHandle,anOffset);
       
   925 
       
   926 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveRead2Ret, EF32TraceUidProxyDrive, r);
       
   927 	return r;
       
   928 	}
       
   929 
       
   930 
       
   931 /**
       
   932 Read from the proxy drive.
       
   933 
       
   934 @param aPos    The address from where the read begins.
       
   935 @param aLength The length of the read.
       
   936 @param aTrg    A descriptor of the memory buffer from which to read.
       
   937 
       
   938 @return system wide error code.
       
   939 */
       
   940 EXPORT_C TInt CBaseExtProxyDrive::Read(TInt64 aPos,TInt aLength,TDes8& aTrg)
       
   941 	{
       
   942 	TRACE5(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveRead3, EF32TraceUidProxyDrive, 
       
   943 		this, I64LOW(aPos), I64HIGH(aPos), aLength, &aTrg);
       
   944 
       
   945 	TInt r = iProxy->Read(aPos,aLength,aTrg);
       
   946 
       
   947 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveRead3Ret, EF32TraceUidProxyDrive, r);
       
   948 	return r;
       
   949 	}
       
   950 
       
   951 
       
   952 /**
       
   953 Write to the proxy drive and pass flags to driver.
       
   954 
       
   955 @param aPos    The address from where the write begins.
       
   956 @param aLength The length of the write.
       
   957 @param aSrc    A descriptor of the memory buffer from which to write.
       
   958 @param aThreadHandle The handle-number representing the drive thread.
       
   959 @param aOffset Offset into aSrc to write the data to.
       
   960 @param aFlags  Flags to be passed into the driver.
       
   961 
       
   962 @return system wide error code.
       
   963 */
       
   964 EXPORT_C TInt CBaseExtProxyDrive::Write(TInt64 aPos,TInt aLength,const TAny* aSrc,TInt aThreadHandle,TInt aOffset,TInt aFlags)
       
   965 	{
       
   966 	TRACETHREADIDH(aThreadHandle);
       
   967 	TRACE8(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveWrite1, EF32TraceUidProxyDrive, 
       
   968 		this, I64LOW(aPos), I64HIGH(aPos), aLength, aSrc, threadId, aOffset, aFlags);
       
   969 
       
   970 	TInt r = iProxy->Write(aPos,aLength,aSrc,aThreadHandle,aOffset,aFlags);
       
   971 
       
   972 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveWrite1Ret, EF32TraceUidProxyDrive, r);
       
   973 	return r;
       
   974 	}
       
   975 
       
   976 
       
   977 /**
       
   978 Write to the proxy drive.
       
   979 
       
   980 @param aPos    The address from where the write begins.
       
   981 @param aLength The length of the write.
       
   982 @param aSrc    A descriptor of the memory buffer from which to write.
       
   983 @param aThreadHandle The handle-number representing the drive thread.
       
   984 @param aOffset Offset into aSrc to write the data to.
       
   985 
       
   986 @return system wide error code.
       
   987 */
       
   988 EXPORT_C TInt CBaseExtProxyDrive::Write(TInt64 aPos,TInt aLength,const TAny* aSrc,TInt aThreadHandle,TInt anOffset)
       
   989 	{
       
   990 	TRACETHREADIDH(aThreadHandle);
       
   991 	TRACE7(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveWrite2, EF32TraceUidProxyDrive, 
       
   992 		this, I64LOW(aPos), I64HIGH(aPos), aLength, aSrc, threadId, anOffset);
       
   993 
       
   994 	TInt r = iProxy->Write(aPos,aLength,aSrc,aThreadHandle,anOffset);
       
   995 
       
   996 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveWrite2Ret, EF32TraceUidProxyDrive, r);
       
   997 	return r;
       
   998 	}
       
   999 
       
  1000 
       
  1001 /**
       
  1002 Write to the proxy drive.
       
  1003 
       
  1004 @param aPos    The address from where the write begins.
       
  1005 @param aSrc    A descriptor of the memory buffer from which to write.
       
  1006 
       
  1007 @return system wide error code.
       
  1008 */
       
  1009 EXPORT_C TInt CBaseExtProxyDrive::Write(TInt64 aPos,const TDesC8& aSrc)
       
  1010 	{
       
  1011 	TRACE5(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveWrite3, EF32TraceUidProxyDrive, 
       
  1012 		this, I64LOW(aPos), I64HIGH(aPos), aSrc.Length(), &aSrc);
       
  1013 
       
  1014 	TInt r = iProxy->Write(aPos,aSrc);
       
  1015 
       
  1016 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveWrite3Ret, EF32TraceUidProxyDrive, r);
       
  1017 	return r;
       
  1018 	}
       
  1019 
       
  1020 
       
  1021 /**
       
  1022 Get the proxy drive's capabilities information.
       
  1023 
       
  1024 @param anInfo A descriptor of the connected drives capabilities.
       
  1025 
       
  1026 @return system wide error code
       
  1027 */
       
  1028 EXPORT_C TInt CBaseExtProxyDrive::Caps(TDes8& anInfo)
       
  1029 	{
       
  1030 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveCaps, EF32TraceUidProxyDrive, this);
       
  1031 
       
  1032 	TInt r = iProxy->Caps(anInfo);
       
  1033 
       
  1034 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveCapsRet, EF32TraceUidProxyDrive, r);
       
  1035 	return r;
       
  1036 	}
       
  1037 
       
  1038 
       
  1039 /**
       
  1040 Format the connected drive.
       
  1041 
       
  1042 @param anInfo Device specific format information.
       
  1043 
       
  1044 @return system wide error code.
       
  1045 */
       
  1046 EXPORT_C TInt CBaseExtProxyDrive::Format(TFormatInfo& anInfo)
       
  1047 	{
       
  1048 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveFormat1, EF32TraceUidProxyDrive, this);
       
  1049 
       
  1050 	TInt r = iProxy->Format(anInfo);
       
  1051 
       
  1052 	TRACE4(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveFormat1Ret, EF32TraceUidProxyDrive, 
       
  1053 		r, anInfo.iFormatIsCurrent, anInfo.i512ByteSectorsFormatted, anInfo.iMaxBytesPerFormat);
       
  1054 	return r;
       
  1055 	}
       
  1056 
       
  1057 
       
  1058 /**
       
  1059 Format the proxy drive.
       
  1060 
       
  1061 @param aPos    The position of the data which is being formatted.
       
  1062 @param aLength The length of the data which is being formatted.
       
  1063 
       
  1064 @return system wide error code.
       
  1065 */
       
  1066 EXPORT_C TInt CBaseExtProxyDrive::Format(TInt64 aPos,TInt aLength)
       
  1067 	{
       
  1068 	TRACE4(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveFormat2, EF32TraceUidProxyDrive, 
       
  1069 		this, I64LOW(aPos), I64HIGH(aPos), aLength);
       
  1070 
       
  1071 	TInt r = iProxy->Format(aPos,aLength);
       
  1072 
       
  1073 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveFormat2Ret, EF32TraceUidProxyDrive, r);
       
  1074 	return r;
       
  1075 	}
       
  1076 
       
  1077 
       
  1078 /**
       
  1079 Set the mount information on the proxy drive.
       
  1080 
       
  1081 @param aMountInfo Information passed down to the media driver. The meaning of this information depends on the media driver.
       
  1082 @param aMountInfoThreadHandle  Message thread handle number.
       
  1083 
       
  1084 @return system wide error code.
       
  1085 */
       
  1086 EXPORT_C TInt CBaseExtProxyDrive::SetMountInfo(const TDesC8* aMountInfo,TInt aMountInfoThreadHandle)
       
  1087 	{
       
  1088 	TRACE3(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveSetMountInfo, EF32TraceUidProxyDrive, this, aMountInfo, aMountInfoThreadHandle);
       
  1089 
       
  1090 	TInt r = iProxy->SetMountInfo(aMountInfo,aMountInfoThreadHandle);
       
  1091 
       
  1092 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveSetMountInfoRet, EF32TraceUidProxyDrive, r);
       
  1093 	return r;
       
  1094 	}
       
  1095 
       
  1096 
       
  1097 /**
       
  1098 Forces a remount on the proxy drive
       
  1099 
       
  1100 @param aFlags Flags to be passed into the driver.
       
  1101 
       
  1102 @return system wide error code.
       
  1103 */
       
  1104 EXPORT_C TInt CBaseExtProxyDrive::ForceRemount(TUint aFlags)
       
  1105 	{
       
  1106 	TRACE2(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveForceRemount, EF32TraceUidProxyDrive, this, aFlags);
       
  1107 
       
  1108 	TInt r = iProxy->ForceRemount(aFlags);
       
  1109 
       
  1110 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveForceRemountRet, EF32TraceUidProxyDrive, r);
       
  1111 	return r;
       
  1112 	}
       
  1113 
       
  1114 
       
  1115 /**
       
  1116 Unlocks a password-enabled proxy drive.
       
  1117 
       
  1118 @param aPassword A descriptor containing the existing password.
       
  1119 @param aStorePassword If ETrue, the password is added to the password store.
       
  1120 
       
  1121 @return system wide error code.
       
  1122 */
       
  1123 EXPORT_C TInt CBaseExtProxyDrive::Unlock(TMediaPassword &aPassword, TBool aStorePassword)
       
  1124 	{
       
  1125 	TRACE2(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveUnlock, EF32TraceUidProxyDrive, this, aStorePassword);
       
  1126 
       
  1127 	TInt r = iProxy->Unlock(aPassword,aStorePassword);
       
  1128 
       
  1129 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveUnlockRet, EF32TraceUidProxyDrive, r);
       
  1130 	return r;
       
  1131 	}
       
  1132 
       
  1133 
       
  1134 /**
       
  1135 Locks a password-enabled proxy drive with the new password.
       
  1136 
       
  1137 @param aOldPassword A descriptor containing the existing password.
       
  1138 @param aNewPassword A descriptor containing the new password.
       
  1139 @param aStorePassword If ETrue, the password is added to the password store.
       
  1140 
       
  1141 @return system wide error code.
       
  1142 */
       
  1143 EXPORT_C TInt CBaseExtProxyDrive::Lock(TMediaPassword &aOldPassword, TMediaPassword &aNewPassword, TBool aStorePassword)
       
  1144 	{
       
  1145 	TRACE2(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveLock, EF32TraceUidProxyDrive, this, aStorePassword);
       
  1146 
       
  1147 	TInt r = iProxy->Lock(aOldPassword,aNewPassword,aStorePassword);
       
  1148 
       
  1149 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveLockRet, EF32TraceUidProxyDrive, r);
       
  1150 	return r;
       
  1151 	}
       
  1152 
       
  1153 
       
  1154 /**
       
  1155 Clears a password from a proxy drive - controller sets password to null.
       
  1156 
       
  1157 @param aPassword A descriptor containing the password.
       
  1158 
       
  1159 @return system wide error code.
       
  1160 */
       
  1161 EXPORT_C TInt CBaseExtProxyDrive::Clear(TMediaPassword &aPassword)
       
  1162 	{
       
  1163 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveClear, EF32TraceUidProxyDrive, this);
       
  1164 
       
  1165 	TInt r = iProxy->Clear(aPassword);
       
  1166 
       
  1167 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveClearRet, EF32TraceUidProxyDrive, r);
       
  1168 	return r;
       
  1169 	}
       
  1170 
       
  1171 /**
       
  1172 Forcibly unlock a password-enabled proxy drive.
       
  1173 
       
  1174 @return system wide error code.
       
  1175 */
       
  1176 EXPORT_C TInt CBaseExtProxyDrive::ErasePassword()
       
  1177 	{
       
  1178 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveErasePassword, EF32TraceUidProxyDrive, this);
       
  1179 
       
  1180 	TInt r = iProxy->ErasePassword();
       
  1181 
       
  1182 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveErasePasswordRet, EF32TraceUidProxyDrive, r);
       
  1183 	return r;
       
  1184 	}
       
  1185 
       
  1186 /**
       
  1187 An interface with which control commands can be passed to 
       
  1188 the appropriate driver layer.
       
  1189 
       
  1190 @param aMessage Message to be sent.
       
  1191 @param aCommand Command type.
       
  1192 @param aParam1  1st parameter of control message.
       
  1193 @param aParam2  2nd parameter of control message.
       
  1194 
       
  1195 @return system wide error code.
       
  1196 */
       
  1197 EXPORT_C TInt CBaseExtProxyDrive::ControlIO(const RMessagePtr2& aMessage,TInt aCommand,TAny* aParam1,TAny* aParam2)
       
  1198 	{
       
  1199 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveControlIO, EF32TraceUidProxyDrive, this);
       
  1200 
       
  1201 	TInt r = iProxy->ControlIO(aMessage,aCommand,aParam1,aParam2);
       
  1202 
       
  1203 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveControlIORet, EF32TraceUidProxyDrive, r);
       
  1204 	return r;
       
  1205 	}
       
  1206 
       
  1207 
       
  1208 /**
       
  1209 Initialise the provided interface extension.
       
  1210 
       
  1211 @param aInterfaceId Interface identifier of the interface to be retrieved.
       
  1212 @param aInterface Address of variable that retrieves the specified interface.
       
  1213 @param aInput Data required for the instantiation of the interface.
       
  1214 
       
  1215 @return system wide error code.
       
  1216 */	
       
  1217 EXPORT_C TInt CBaseExtProxyDrive::GetInterface(TInt aInterfaceId,TAny*& aInterface,TAny* aInput)
       
  1218 	{
       
  1219 	TRACE3(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveGetInterface, EF32TraceUidProxyDrive, 
       
  1220 		this, aInterfaceId, aInput);
       
  1221 
       
  1222 	TInt r;
       
  1223 	if (aInterfaceId==EGetLocalDrive)
       
  1224 		{
       
  1225 		r = iProxy->GetLocalDrive((TBusLocalDrive*&)aInterface);		// iProxy is of type CLocalProxyDrive, so OK to reenter
       
  1226 		}
       
  1227 	else	
       
  1228 		r = CProxyDrive::GetInterface(aInterfaceId,aInterface,aInput);
       
  1229 
       
  1230 	TRACERET2(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveGetInterfaceRet, EF32TraceUidProxyDrive, r, aInterface);
       
  1231 	return r;
       
  1232 	}	
       
  1233 
       
  1234 
       
  1235 /**
       
  1236 Retrieve proxy drive disk error information.
       
  1237 
       
  1238 @param aErrorInfo Reference to a descriptor containing disk error information.
       
  1239 
       
  1240 @return System wide error code.
       
  1241 */
       
  1242 EXPORT_C TInt CBaseExtProxyDrive::GetLastErrorInfo(TDes8 &aErrorInfo)
       
  1243 	{
       
  1244 	TRACE1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveGetLastErrorInfo, EF32TraceUidProxyDrive, this);
       
  1245 
       
  1246 	TInt r = iProxy->GetLastErrorInfo(aErrorInfo);
       
  1247 
       
  1248 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveGetLastErrorInfoRet, EF32TraceUidProxyDrive, r);
       
  1249 	return r;
       
  1250 	}
       
  1251 
       
  1252 
       
  1253 /**
       
  1254 Issue a notification that a physical delete has occurred. 
       
  1255 For example a cluster or partition has been freed.
       
  1256 
       
  1257 @param aPos    The position of the data which is being deleted.
       
  1258 @param aLength The length of the data which is being deleted.
       
  1259 
       
  1260 @return System wide error code.
       
  1261 */
       
  1262 EXPORT_C TInt CBaseExtProxyDrive::DeleteNotify(TInt64 aPos, TInt aLength)
       
  1263     {
       
  1264 	TRACE4(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveDeleteNotify, EF32TraceUidProxyDrive, 
       
  1265 		this, I64LOW(aPos), I64HIGH(aPos), aLength);
       
  1266 
       
  1267     TInt r = iProxy->DeleteNotify(aPos, aLength);
       
  1268 
       
  1269 	TRACERET1(UTF::EBorder, UTraceModuleProxyDrive::ECBaseExtProxyDriveDeleteNotifyRet, EF32TraceUidProxyDrive, r);
       
  1270 	return r;
       
  1271     }
       
  1272 
       
  1273 
       
  1274 /**
       
  1275 Constructor.
       
  1276 */
       
  1277 EXPORT_C CProxyDriveFactory::CProxyDriveFactory()
       
  1278 	{}
       
  1279 
       
  1280 
       
  1281 /**
       
  1282 Remove the Proxy driver factory.
       
  1283 
       
  1284 This implementation performs no operations.
       
  1285 
       
  1286 @return KErrNone
       
  1287 */
       
  1288 EXPORT_C TInt CProxyDriveFactory::Remove()
       
  1289 	{
       
  1290 	return(KErrNone);
       
  1291 	}
       
  1292 
       
  1293 GLDEF_C CExtProxyDriveFactory* GetProxyDriveFactory(const TDesC& aName)
       
  1294 //
       
  1295 // Lookup an extension by name.
       
  1296 //
       
  1297 	{
       
  1298 
       
  1299 	TInt h=0;
       
  1300 	TInt r=ProxyDrives->FindByName(h,aName);
       
  1301 	if (r!=KErrNone)
       
  1302 		return(NULL);
       
  1303 	return((CExtProxyDriveFactory*)ProxyDrives->At(h));
       
  1304 	}
       
  1305 
       
  1306 
       
  1307 // construct a extension proxy drive device
       
  1308 EXPORT_C CExtProxyDriveFactory::CExtProxyDriveFactory()
       
  1309 	{
       
  1310 	}
       
  1311 
       
  1312 
       
  1313 EXPORT_C TInt CExtProxyDriveFactory::Remove()
       
  1314 	{
       
  1315 	return KErrNone;
       
  1316 	}
       
  1317 
       
  1318 
       
  1319 EXPORT_C void CExtProxyDriveFactory::AsyncEnumerate()
       
  1320 	{
       
  1321 	}
       
  1322 
       
  1323 
       
  1324 /**
       
  1325 Create a proxy drive using the local proxy drive passed in
       
  1326 and any extensions that have been added to the drive.
       
  1327 
       
  1328 @param aConcreteDrive local proxy drive
       
  1329 @param aMount local proxy drive mount control block
       
  1330 
       
  1331 @return pointer to instantiated CProxyDrive object.
       
  1332 */
       
  1333 EXPORT_C CProxyDrive* CreateProxyDriveL(CProxyDrive* aConcreteDrive,CMountCB* aMount)
       
  1334 	{
       
  1335 	__PRINT(_L("CreateProxyDriveL()"));
       
  1336 	__ASSERT_DEBUG(aMount!=NULL,Fault(ECreateProxyDriveL));
       
  1337 	TDrive& drive=TheDrives[aMount->Drive().DriveNumber()];
       
  1338 	if(drive.ExtInfo().iCount==0)
       
  1339 		return(aConcreteDrive);
       
  1340 
       
  1341 	TBool extSupported = drive.FSys().IsExtensionSupported();
       
  1342 	TRACE1(UTF::EBorder, UTraceModuleFileSys::ECFileSystemIsExtensionSupported, EF32TraceUidProxyDrive, extSupported);
       
  1343 	if(!extSupported)
       
  1344 		{
       
  1345 		delete(aConcreteDrive);
       
  1346 		User::Leave(KErrAccessDenied);
       
  1347 		}
       
  1348 	CProxyDrive* pOrig=aConcreteDrive;
       
  1349 	CProxyDrive* pFinal=NULL;
       
  1350 	__ASSERT_DEBUG(drive.ExtInfo().iCount<=KMaxExtensionCount,Fault(EExtensionInfoCount2));
       
  1351 	for(TInt i=0;i<drive.ExtInfo().iCount;++i)
       
  1352 		{
       
  1353 		__PRINT1TEMP(_L("adding extension %S"),drive.ExtInfo().iInfo[i].iFactory->Name());
       
  1354 		__PRINT1(_L("extension is primary = %d"),drive.ExtInfo().iInfo[i].iIsPrimary);
       
  1355 		TRAPD(r,pFinal=drive.ExtInfo().iInfo[i].iFactory->NewProxyDriveL(pOrig,aMount));
       
  1356 		if(r!=KErrNone)
       
  1357 			{
       
  1358 			delete(pOrig);
       
  1359 			User::Leave(r);
       
  1360 			}
       
  1361 		pOrig=pFinal;
       
  1362 		}
       
  1363 	return(pOrig);
       
  1364 	}
       
  1365 
       
  1366 /**
       
  1367 Lookup a proxy drive extension by name.
       
  1368 
       
  1369 @param aName name of extension to be found
       
  1370 
       
  1371 @return system wide error code
       
  1372 */
       
  1373 CProxyDriveFactory* GetExtension(const TDesC& aName)
       
  1374 	{
       
  1375 
       
  1376 	TInt h=0;
       
  1377 	TInt r=Extensions->FindByName(h,aName);
       
  1378 	if (r!=KErrNone)
       
  1379 		return(NULL);
       
  1380 	return((CProxyDriveFactory*)Extensions->At(h));
       
  1381 	}
       
  1382 
       
  1383 
       
  1384 // construct a extension proxy drive
       
  1385 EXPORT_C CExtProxyDrive::CExtProxyDrive(CMountCB* aMount,CExtProxyDriveFactory* aDevice)
       
  1386   : CProxyDrive(aMount),
       
  1387 	iFactory(aDevice)
       
  1388 	{
       
  1389 	}
       
  1390 
       
  1391 // delete a extension proxy drive
       
  1392 EXPORT_C CExtProxyDrive::~CExtProxyDrive()
       
  1393 	{
       
  1394 	if(iMediaChangeNotifier)
       
  1395 		{
       
  1396 		delete iMediaChangeNotifier;
       
  1397 		}
       
  1398 	}
       
  1399 
       
  1400 
       
  1401 EXPORT_C TInt CExtProxyDrive::NotifyChange(TDes8 &/*aChanged*/, TRequestStatus* /*aStatus*/)
       
  1402 	{
       
  1403 	return KErrNotSupported;
       
  1404 	}	
       
  1405 
       
  1406 EXPORT_C void CExtProxyDrive::NotifyChangeCancel()
       
  1407 	{
       
  1408 	}	
       
  1409 
       
  1410 EXPORT_C TInt CExtProxyDrive::SetInfo(const RMessage2& /*aMsg*/, TAny* /*aMessageParam2*/, TAny* /*aMessageParam3*/)
       
  1411     {
       
  1412 	return KErrNone;
       
  1413     }
       
  1414 
       
  1415 /**
       
  1416 Initialise the provided interface extension.
       
  1417 
       
  1418 @param aInterfaceId Interface identifier of the interface to be retrieved.
       
  1419 @param aInterface Address of variable that retrieves the specified interface.
       
  1420 @param aInput Data required for the instantiation of the interface.
       
  1421 
       
  1422 @return system wide error code.
       
  1423 */	
       
  1424 EXPORT_C TInt CExtProxyDrive::GetInterface(TInt aInterfaceId,TAny*& aInterface,TAny* aInput)
       
  1425 	{
       
  1426 	return(CProxyDrive::GetInterface(aInterfaceId,aInterface,aInput));
       
  1427 	}	
       
  1428 
       
  1429 TInt CExtProxyDrive::SetupMediaChange()
       
  1430 	{
       
  1431 	if(iMediaChangeNotifier)
       
  1432 		{
       
  1433 		TRAPD(err, iMediaChangeNotifier->RequestL());
       
  1434 		return err;
       
  1435 		}
       
  1436 
       
  1437 	TRAPD(err, iMediaChangeNotifier = CExtNotifyMediaChange::NewL(this));	
       
  1438 
       
  1439 	return(err == KErrNotSupported ? KErrNone : err);
       
  1440 	}
       
  1441 
       
  1442 TInt TFsAddExtension::DoRequestL(CFsRequest* aRequest)
       
  1443 //
       
  1444 // Add an extension
       
  1445 //
       
  1446 	{
       
  1447 	__PRINT(_L("TFsAddExtension::DoRequestL(CFsRequest* aRequest)"));
       
  1448 	
       
  1449 	RLibrary lib;
       
  1450 	// Get library handle
       
  1451 	lib.SetHandle(aRequest->Message().Int0());
       
  1452 	if (lib.Type()[1]!=TUid::Uid(KFileSystemUidValue))
       
  1453 		return KErrNotSupported;
       
  1454 
       
  1455     TExtensionNew e=(TExtensionNew)lib.Lookup(1);
       
  1456 	if (!e)
       
  1457 		return KErrCorrupt;
       
  1458 	CProxyDriveFactory* pP=(*e)();
       
  1459 	if(!pP)
       
  1460 		return KErrNoMemory;
       
  1461 	TInt r=pP->Install();
       
  1462 	__PRINT1TEMP(_L("InstallExtension %S"),pP->Name());
       
  1463 	if (r==KErrNone)
       
  1464 		{
       
  1465 		__PRINT(_L("TRAP(r,Extensions->AddL(pP,ETrue))"));
       
  1466 		TRAP(r,Extensions->AddL(pP,ETrue))
       
  1467 		__PRINT1TEMP(_L("r == %d"), r);
       
  1468 		if(r!=KErrNone)
       
  1469 			pP->Remove();
       
  1470 		}
       
  1471 	__PRINT1TEMP(_L("r == %d"), r);
       
  1472 	if (r==KErrNone)
       
  1473 		pP->SetLibrary(lib);
       
  1474 	else
       
  1475 		pP->Close();
       
  1476 	return(r);
       
  1477 	}
       
  1478 
       
  1479 
       
  1480 TInt TFsAddExtension::Initialise(CFsRequest* aRequest)
       
  1481 //
       
  1482 //
       
  1483 //
       
  1484 	{
       
  1485 	TSecurityPolicy policy(RProcess().SecureId(), ECapabilityTCB);
       
  1486 	if (!policy.CheckPolicy(aRequest->Message(), __PLATSEC_DIAGNOSTIC_STRING("Add File System Extension")))
       
  1487 		return KErrPermissionDenied;
       
  1488 	return KErrNone;
       
  1489 	}
       
  1490 
       
  1491 TInt TFsAddProxyDrive::DoRequestL(CFsRequest* aRequest)
       
  1492 //
       
  1493 // Load a proxy drive
       
  1494 //
       
  1495 	{
       
  1496 	__PRINT(_L("TFsAddProxyDrive::DoRequestL(CFsRequest* aRequest)"));
       
  1497 	
       
  1498 	RLibrary lib;
       
  1499 	// Get library handle
       
  1500 	lib.SetHandle(aRequest->Message().Int0());
       
  1501 	if (lib.Type()[1]!=TUid::Uid(KFileSystemUidValue))
       
  1502 		return KErrNotSupported;
       
  1503 
       
  1504     TProxyDriveNew e=(TProxyDriveNew)lib.Lookup(1);
       
  1505 	if (!e)
       
  1506 		return KErrCorrupt;
       
  1507 	CExtProxyDriveFactory* pP=(*e)();
       
  1508 	if(!pP)
       
  1509 		return KErrNoMemory;
       
  1510 	TInt r=pP->Install();
       
  1511 	__PRINT1TEMP(_L("Install Proxy Drive %S"),pP->Name());
       
  1512 	if (r==KErrNone)
       
  1513 		{
       
  1514 		__PRINT(_L("TRAP(r,ProxyDrives->AddL(pP,ETrue))"));
       
  1515 		TRAP(r,ProxyDrives->AddL(pP,ETrue))
       
  1516 		__PRINT1TEMP(_L("r == %d"), r);
       
  1517 		if(r!=KErrNone)
       
  1518 			pP->Remove();
       
  1519 		}
       
  1520 	__PRINT1TEMP(_L("r == %d"), r);
       
  1521 	if (r==KErrNone)
       
  1522 		pP->SetLibrary(lib);
       
  1523 	else
       
  1524 		pP->Close();
       
  1525 	return(r);
       
  1526 	}
       
  1527 
       
  1528 
       
  1529 TInt TFsAddProxyDrive::Initialise(CFsRequest* aRequest)
       
  1530 //
       
  1531 //
       
  1532 //
       
  1533 	{
       
  1534 	TSecurityPolicy policy(RProcess().SecureId(), ECapabilityTCB);
       
  1535 	if (!policy.CheckPolicy(aRequest->Message(), __PLATSEC_DIAGNOSTIC_STRING("Add File System Proxy Drive")))
       
  1536 		return KErrPermissionDenied;
       
  1537 	return KErrNone;
       
  1538 	}
       
  1539 
       
  1540 TInt TFsMountExtension::DoRequestL(CFsRequest* aRequest)
       
  1541 //
       
  1542 // Mount an extension
       
  1543 //
       
  1544 	{
       
  1545 	TFullName name;
       
  1546 	aRequest->ReadL(KMsgPtr0,name);
       
  1547 	CProxyDriveFactory* pE=GetExtension(name);
       
  1548 	if (pE==NULL)
       
  1549 		return(KErrNotFound);
       
  1550 	return(aRequest->Drive()->MountExtension(pE,EFalse));
       
  1551 	}
       
  1552 
       
  1553 TInt TFsMountExtension::Initialise(CFsRequest* aRequest)
       
  1554 //
       
  1555 //
       
  1556 //
       
  1557 	{
       
  1558 	TInt r=ValidateDrive(aRequest->Message().Int1(),aRequest);
       
  1559 	if(r!=KErrNone)
       
  1560 		return(r);
       
  1561 	if(aRequest->Drive()->IsSubsted())
       
  1562 		return(KErrNotSupported);
       
  1563 	return(r);
       
  1564 	}
       
  1565 
       
  1566 
       
  1567 TInt TFsDismountExtension::DoRequestL(CFsRequest* aRequest)
       
  1568 //
       
  1569 // Dismount extension
       
  1570 //
       
  1571 	{
       
  1572 	TFullName name;
       
  1573 	aRequest->ReadL(KMsgPtr0,name);
       
  1574 	CProxyDriveFactory* pE=GetExtension(name);
       
  1575 	if (pE==NULL)
       
  1576 		return(KErrNotFound);
       
  1577 	return(aRequest->Drive()->DismountExtension(pE,EFalse));
       
  1578 	}
       
  1579 
       
  1580 
       
  1581 TInt TFsDismountExtension::Initialise(CFsRequest* aRequest)
       
  1582 //
       
  1583 //
       
  1584 //
       
  1585 	{
       
  1586 	if (!KCapFsDismountExtension.CheckPolicy(aRequest->Message(), __PLATSEC_DIAGNOSTIC_STRING("Dismount File Extension")))
       
  1587 		return KErrPermissionDenied;
       
  1588 	TInt r=ValidateDrive(aRequest->Message().Int1(),aRequest);
       
  1589 	if(r!=KErrNone)
       
  1590 		return(r);
       
  1591 	if(aRequest->Drive()->IsSubsted())
       
  1592 		return(KErrNotSupported);
       
  1593 	return(r);
       
  1594 	}
       
  1595 
       
  1596 TInt TFsRemoveExtension::DoRequestL(CFsRequest* aRequest)
       
  1597 //
       
  1598 // Remove an extension
       
  1599 //
       
  1600 	{
       
  1601 	TFullName name;
       
  1602 	aRequest->ReadL(KMsgPtr0,name);
       
  1603 	CProxyDriveFactory* pE=GetExtension(name);
       
  1604 	if (pE==NULL)
       
  1605 		return(KErrNotFound);
       
  1606 	TInt r=pE->Remove();
       
  1607 	if (r!=KErrNone)
       
  1608 		return(r);
       
  1609 	RLibrary lib=pE->Library();
       
  1610 	pE->Close();
       
  1611 	lib.Close();
       
  1612 	return(KErrNone);
       
  1613 	}
       
  1614 
       
  1615 
       
  1616 TInt TFsRemoveExtension::Initialise(CFsRequest* aRequest)
       
  1617 //
       
  1618 //
       
  1619 //
       
  1620 	{
       
  1621 	if (!KCapFsRemoveExtension.CheckPolicy(aRequest->Message(), __PLATSEC_DIAGNOSTIC_STRING("Remove File Extension")))
       
  1622 		return KErrPermissionDenied;
       
  1623 	return KErrNone;
       
  1624 	}
       
  1625 
       
  1626 TInt TFsRemoveProxyDrive::DoRequestL(CFsRequest* aRequest)
       
  1627 //
       
  1628 // Remove a proxy drive
       
  1629 //
       
  1630 	{
       
  1631 	TFullName name;
       
  1632 	aRequest->ReadL(KMsgPtr0,name);
       
  1633 
       
  1634 	CExtProxyDriveFactory* pD=GetProxyDriveFactory(name);
       
  1635 	// are there any mounted drives using this extension?
       
  1636 	if (LocalDrives::IsProxyDriveInUse(pD)) return KErrInUse;
       
  1637 	if (pD==NULL)
       
  1638 		return(KErrNotFound);
       
  1639 	TInt r=pD->Remove();
       
  1640 	if (r!=KErrNone)
       
  1641 		return(r);
       
  1642 	RLibrary lib=pD->Library();
       
  1643 	pD->Close();
       
  1644 	lib.Close();
       
  1645 
       
  1646 	return(KErrNone);
       
  1647 	}
       
  1648 
       
  1649 
       
  1650 TInt TFsRemoveProxyDrive::Initialise(CFsRequest* aRequest)
       
  1651 //
       
  1652 //
       
  1653 //
       
  1654 	{
       
  1655 	if (!KCapFsRemoveProxyDrive.CheckPolicy(aRequest->Message(), __PLATSEC_DIAGNOSTIC_STRING("Remove Proxy Drive")))
       
  1656 		return KErrPermissionDenied;
       
  1657 	return KErrNone;
       
  1658 	}
       
  1659 
       
  1660 TInt TFsExtensionName::DoRequestL(CFsRequest* aRequest)
       
  1661 //
       
  1662 // Return the name of an extension for a given drive and extension chain position
       
  1663 //
       
  1664 	{
       
  1665 	TFullName name;
       
  1666 	TInt r=aRequest->Drive()->ExtensionName(name,aRequest->Message().Int2());
       
  1667 	if(r==KErrNone)
       
  1668 		aRequest->WriteL(KMsgPtr0,name);
       
  1669 	return(r);
       
  1670 	}
       
  1671 
       
  1672 TInt TFsExtensionName::Initialise(CFsRequest* aRequest)
       
  1673 //
       
  1674 //
       
  1675 //
       
  1676 	{
       
  1677 	TInt r=ValidateDrive(aRequest->Message().Int1(),aRequest);
       
  1678 	if(r!=KErrNone)
       
  1679 		return(r);
       
  1680 	if(aRequest->Drive()->IsSubsted())
       
  1681 		return(KErrNotSupported);
       
  1682 	return(r);
       
  1683 	}
       
  1684 
       
  1685 TInt TFsDismountProxyDrive::DoRequestL(CFsRequest* aRequest)
       
  1686 //
       
  1687 // Dismount a proxy extension
       
  1688 //
       
  1689 	{
       
  1690 
       
  1691 	__PRINT(_L("TFsDismountProxyDrive::DoRequestL"));
       
  1692 
       
  1693 	return aRequest->Drive()->DismountProxyDrive();
       
  1694 	}
       
  1695 
       
  1696 
       
  1697 TInt TFsDismountProxyDrive::Initialise(CFsRequest* aRequest)
       
  1698 //
       
  1699 //
       
  1700 //
       
  1701 	{
       
  1702 	if (!KCapFsDismountProxyDrive.CheckPolicy(aRequest->Message(), __PLATSEC_DIAGNOSTIC_STRING("Dismount Proxy Drive")))
       
  1703 		return KErrPermissionDenied;
       
  1704 
       
  1705 	TInt r=ValidateDrive(aRequest->Message().Int0(),aRequest);
       
  1706 	if(r!=KErrNone)
       
  1707 		return(r);
       
  1708 
       
  1709 	return KErrNone;
       
  1710 	}
       
  1711