baseport/syborg/svphostfs/fs/svphostmnt.cpp
changeset 2 d55eb581a87c
parent 0 ffa851df0825
child 15 5fca9e46c6fa
equal deleted inserted replaced
1:2fb8b9db1c86 2:d55eb581a87c
       
     1 /*
       
     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
       
     3 * All rights reserved.
       
     4 * This component and the accompanying materials are made available
       
     5 * under the terms of the License "Eclipse Public License v1.0"
       
     6 * which accompanies this distribution, and is available
       
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8 *
       
     9 * Initial Contributors:
       
    10 * Nokia Corporation - initial contribution.
       
    11 *
       
    12 * Contributors:
       
    13 *
       
    14 * Description:
       
    15 *
       
    16 */
       
    17 
       
    18 #include <f32file.h>
       
    19 #include <f32fsys.h>
       
    20 #include <f32ver.h>
       
    21 #include <e32uid.h>
       
    22 
       
    23 #include "svphostfsy.h"
       
    24 
       
    25 #define HOST_SVP_DRIVE_SIZE 1024*1024*1024
       
    26 #define HOST_SVP_DRIVE_FREE_SIZE 10*1024*1024
       
    27 
       
    28 LOCAL_C TInt GetMediaSize(TInt /*aDriveNumber*/,TInt64& aSize,TInt64& aFree)
       
    29 //
       
    30 // Return the size and free space on a drive.
       
    31 //
       
    32 	{
       
    33         DP(_L("** (SVPHOSTMNT) GetMediaSize"));
       
    34 
       
    35 	aSize = HOST_SVP_DRIVE_SIZE;
       
    36 	aFree = HOST_SVP_DRIVE_FREE_SIZE;
       
    37 	return(KErrNone);
       
    38 	}
       
    39 
       
    40 LOCAL_C TInt GetVolume(TInt /*aDriveNumber*/,TDes& aName,TUint& aUniqueID)
       
    41 //
       
    42 // Return the volume name and uniqueID.
       
    43 //
       
    44 	{
       
    45         DP(_L("** (SVPHOSTMNT) GetVolume"));
       
    46 
       
    47 	aUniqueID=1234;
       
    48 	aName=(_L("SVPHOSTDRV"));
       
    49 	return(KErrNone);	
       
    50 	}
       
    51 
       
    52 void CanonicalizePathname(const TDesC& aName, TInt aDrive, TDes& n, THostFileName& aHostName)
       
    53         {
       
    54 	DP(_L("** (SVPHOSTMNT) CanonicalizePathname (%S)"), &aName);
       
    55 	n += TDriveUnit(aDrive).Name();
       
    56 	n += aName;
       
    57 	TParse parse;
       
    58 	parse.Set(n,NULL,NULL);
       
    59 	n=parse.FullName();
       
    60 	aHostName.Copy(n);
       
    61 	DP(_L("-> (%S)"), &aHostName);
       
    62 	}
       
    63 
       
    64 void CanonicalizePathname(const TDesC& aName, TInt aDrive, THostFileName& aHostName)
       
    65         {
       
    66 	TUint16 buf[KMaxPath];
       
    67 	TPtr n(buf, KMaxPath);
       
    68 	CanonicalizePathname(aName, aDrive, n, aHostName);
       
    69 	}
       
    70 
       
    71 
       
    72 
       
    73 //////////////////////////////////////////////////////////////////////////
       
    74 //	CSVPHostMountCB							//
       
    75 //////////////////////////////////////////////////////////////////////////	
       
    76 
       
    77 
       
    78 CSVPHostMountCB::CSVPHostMountCB()
       
    79 	{
       
    80         DP(_L("** (SVPHOSTMNT) CSVPHostMountCB::CSVPHostMountCB()"));
       
    81 
       
    82 	__DECLARE_NAME(_S("CSVPHostMountCB"));
       
    83 	}
       
    84 
       
    85 CSVPHostMountCB::~CSVPHostMountCB()
       
    86 	{
       
    87 	DP(_L("** (SVPHOSTMNT) CSVPHostMountCB::~CSVPHostMountCB()"));
       
    88 	iDevice.Close();
       
    89 	}
       
    90 
       
    91 void CSVPHostMountCB::MountL(TBool /*aForceMount*/)
       
    92 	{
       
    93         DP(_L("** (SVPHOSTMNT) CSVPHostMountCB::MountL()"));
       
    94 
       
    95 	TInt err = iDevice.Open();
       
    96 	User::LeaveIfError(err);
       
    97 
       
    98 	TFileName driveName;
       
    99 	TInt d=Drive().DriveNumber();
       
   100 	iSize=HOST_SVP_DRIVE_SIZE;
       
   101 	User::LeaveIfError(GetVolume(d,driveName,iUniqueID));
       
   102 	HBufC* pN=driveName.AllocL();
       
   103 	DP(_L("** (SVPHOSTMNT) ->SetVolumeName()"));
       
   104 	SetVolumeName(pN);
       
   105 	DP(_L("** (SVPHOSTMNT) <-SetVolumeName()"));
       
   106 
       
   107 	}
       
   108 
       
   109 TInt CSVPHostMountCB::ReMount()
       
   110 	{
       
   111         DP(_L("** (SVPHOSTMNT) CSVPHostMountCB::ReMount()"));
       
   112 
       
   113 	TFileName n;
       
   114 	TInt d=Drive().DriveNumber();
       
   115 	TUint uniqueID;
       
   116 	TInt r=GetVolume(d,n,uniqueID);
       
   117 	if (r!=KErrNone)
       
   118 		return(r);
       
   119 	if (n==VolumeName() && uniqueID==iUniqueID)
       
   120 		return(KErrNone);
       
   121 	return(KErrGeneral);
       
   122 	}
       
   123 
       
   124 void CSVPHostMountCB::Dismounted()
       
   125 	{
       
   126         DP(_L("** (SVPHOSTMNT) CSVPHostMountCB::Dismounted()"));
       
   127 	}
       
   128 
       
   129 void CSVPHostMountCB::VolumeL(TVolumeInfo& aVolume) const
       
   130 	{
       
   131         DP(_L("** (SVPHOSTMNT) CSVPHostMountCB::VolumeL()"));
       
   132 	TInt64 s,f(0);
       
   133 	TFileName n;
       
   134 	TInt d=Drive().DriveNumber();
       
   135 	User::LeaveIfError(GetMediaSize(d,s,f));
       
   136 	aVolume.iFree=f;
       
   137 	}
       
   138 
       
   139 void CSVPHostMountCB::SetVolumeL(TDes& /*aName*/)
       
   140 	{
       
   141         DP(_L("** (SVPHOSTMNT) CSVPHostMountCB::SetVolumeL()"));
       
   142 	User::Leave(KErrNotSupported);
       
   143 	}
       
   144 
       
   145 void CSVPHostMountCB::IsFileInRom(const TDesC& /*aName*/,TUint8*& /*aFileStart*/)
       
   146 	{
       
   147         DP(_L("** (SVPHOSTMNT) CSVPHostMountCB::IsFileInRom()"));
       
   148 	}
       
   149 
       
   150 void CSVPHostMountCB::MkDirL(const TDesC& aName)
       
   151 	{
       
   152         DP(_L("** (SVPHOSTMNT) CSVPHostMountCB::MkDirL()"));
       
   153 	TBuf<KMaxPath> name;
       
   154 	TUint driveNumber = Drive().DriveNumber();
       
   155 	CanonicalizePathname(aName, driveNumber, name);
       
   156 	TSVPHostFsMkDirInfo info(driveNumber, name, 0777);
       
   157 	User::LeaveIfError(SVP_HOST_FS_DEVICE().MkDir(info));
       
   158 	}
       
   159 
       
   160 void CSVPHostMountCB::RmDirL(const TDesC& aName)
       
   161 	{
       
   162         DP(_L("** (SVPHOSTMNT) CSVPHostMountCB::RmDirL()"));
       
   163 	TBuf<KMaxPath> name;
       
   164 	TUint driveNumber = Drive().DriveNumber();
       
   165 	CanonicalizePathname(aName, driveNumber, name);
       
   166 	TSVPHostFsRmDirInfo info(driveNumber, name);
       
   167 	User::LeaveIfError(SVP_HOST_FS_DEVICE().RmDir(info));
       
   168 	}
       
   169 
       
   170 void CSVPHostMountCB::DeleteL(const TDesC& aName)
       
   171 	{
       
   172         DP(_L("** (SVPHOSTMNT) CSVPHostMountCB::DeleteL()"));
       
   173 	TBuf<KMaxPath> name;
       
   174 	TUint driveNumber = Drive().DriveNumber();
       
   175 	CanonicalizePathname(aName, driveNumber, name);
       
   176 	TSVPHostFsDeleteInfo info(driveNumber, name);
       
   177 	User::LeaveIfError(SVP_HOST_FS_DEVICE().Delete(info));
       
   178 	}
       
   179 
       
   180 void CSVPHostMountCB::RenameL(const TDesC& anOldName,const TDesC& aNewName)
       
   181 	{
       
   182         DP(_L("** (SVPHOSTMNT) CSVPHostMountCB::RenameL()"));
       
   183 	// TODO: do we allow renaming across drives?
       
   184 	TBuf<KMaxPath> oldName, newName;
       
   185 	TUint driveNumber = Drive().DriveNumber();
       
   186 	CanonicalizePathname(anOldName, driveNumber, oldName);
       
   187 	CanonicalizePathname(aNewName, driveNumber, newName);
       
   188 	TSVPHostFsRenameInfo info(driveNumber, oldName, newName);
       
   189 	User::LeaveIfError(SVP_HOST_FS_DEVICE().Rename(info));
       
   190 	}
       
   191 
       
   192 void CSVPHostMountCB::ReplaceL(const TDesC& anOldName,const TDesC& aNewName)
       
   193 	{
       
   194         DP(_L("** (SVPHOSTMNT) CSVPHostMountCB::ReplaceL()"));
       
   195 
       
   196 	if(FileNamesIdentical(anOldName,aNewName))
       
   197 		{
       
   198 		return;
       
   199 		}
       
   200 	TBuf<KMaxPath> oldName, newName;
       
   201 	TUint driveNumber = Drive().DriveNumber();
       
   202 	CanonicalizePathname(anOldName, driveNumber, oldName);
       
   203 	CanonicalizePathname(aNewName, driveNumber, newName);
       
   204 	TSVPHostFsReplaceInfo info(driveNumber, oldName, newName);
       
   205 	User::LeaveIfError(SVP_HOST_FS_DEVICE().Replace(info));
       
   206 	}
       
   207 
       
   208 void CSVPHostMountCB::ReadUidL(const TDesC& aName,TEntry& anEntry) const
       
   209 	{
       
   210         DP(_L("** (SVPHOSTMNT) CSVPHostMountCB::ReadUidL()"));
       
   211 	TBuf<KMaxPath> name;
       
   212 	TUint driveNumber = Drive().DriveNumber();
       
   213 	CanonicalizePathname(aName, driveNumber, name);
       
   214 	TSVPHostFsFileOpenInfo fileOpenInfo(driveNumber, name,EFileRead,EFileOpen);
       
   215 	TInt err = SVP_HOST_FS_DEVICE().FileOpen(fileOpenInfo);
       
   216 
       
   217 	User::LeaveIfError(err);
       
   218 
       
   219 	TBuf8<sizeof(TCheckedUid)> uidBuf;
       
   220 	uidBuf.SetLength(sizeof(TCheckedUid));
       
   221 
       
   222 	TSVPHostFsFileReadInfo fileReadInfo(driveNumber, fileOpenInfo.iHandle,sizeof(TCheckedUid),0,(char*)uidBuf.Ptr());
       
   223 
       
   224 	if (KErrNone != SVP_HOST_FS_DEVICE().FileRead(fileReadInfo))
       
   225 		User::LeaveIfError(SVP_HOST_FS_DEVICE().FileClose(driveNumber, fileOpenInfo.iHandle));
       
   226 
       
   227 	DP(_L("** (SVPHOSTMNT) CSVPHostFileCB::ReadUidL sizeof(TCheckedUid) %d fileOpenInfo.iLength %d "), sizeof(TCheckedUid), fileReadInfo.iLength);
       
   228 
       
   229 	if (fileReadInfo.iLength!=sizeof(TCheckedUid))
       
   230 	        User::LeaveIfError(SVP_HOST_FS_DEVICE().FileClose(driveNumber, fileOpenInfo.iHandle));
       
   231 
       
   232 	TCheckedUid uid(uidBuf);
       
   233 	anEntry.iType=uid.UidType();
       
   234 
       
   235 	User::LeaveIfError(SVP_HOST_FS_DEVICE().FileClose(driveNumber, fileOpenInfo.iHandle));
       
   236 	}
       
   237 
       
   238 void CSVPHostMountCB::EntryL(const TDesC& aName,TEntry& anEntry) const
       
   239 	{
       
   240 	DP(_L("** (SVPHOSTMNT) CSVPHostMountCB::EntryL(%S)"), &aName);
       
   241 	TBuf<KMaxPath> name;
       
   242 	TUint driveNumber = Drive().DriveNumber();
       
   243 	CanonicalizePathname(aName, driveNumber, name);
       
   244 	TSVPHostFsEntryInfo info(driveNumber, name);
       
   245 	User::LeaveIfError(SVP_HOST_FS_DEVICE().Entry(info));
       
   246 	anEntry.iAtt=info.iAtt&KEntryAttMaskSupported;
       
   247 	anEntry.iSize=info.iSize;
       
   248 	fileTimeToTime(info.iModified,anEntry.iModified, info.iTimeType);
       
   249 
       
   250 	}
       
   251 
       
   252 void timeToFileTime(TUint32& t,const TTime& aTime, TFileTimeType aType);
       
   253 
       
   254 void CSVPHostMountCB::SetEntryL(const TDesC& aName,const TTime& aTime,TUint aSetAttMask,TUint aClearAttMask)
       
   255 	{
       
   256 	DP(_L("** (SVPHOSTMNT) CSVPHostMountCB::SetEntryL()"));
       
   257 
       
   258 	//User::Leave(KErrNotSupported);
       
   259 	}
       
   260 
       
   261 void CSVPHostMountCB::FileOpenL(const TDesC& aName,TUint aMode,TFileOpen anOpen,CFileCB* aFile)
       
   262 	{
       
   263 	DP(_L("** (SVPHOSTMNT) CSVPHostMountCB::FileOpenL(%S)"), &aName);
       
   264 	CSVPHostFileCB& file=(*((CSVPHostFileCB*)aFile));
       
   265 
       
   266 	TBuf<KMaxPath> name;
       
   267 	TUint driveNumber = Drive().DriveNumber();
       
   268 	CanonicalizePathname(aName, driveNumber, name);
       
   269 	TSVPHostFsFileOpenInfo info(driveNumber, name,aMode,anOpen);
       
   270 	TInt err = SVP_HOST_FS_DEVICE().FileOpen(info);
       
   271 
       
   272 	User::LeaveIfError(err);
       
   273 
       
   274 	file.SetHandle(info.iHandle);
       
   275 	file.SetSize(info.iSize);
       
   276 	file.SetAtt(info.iAtt&KEntryAttMaskSupported);
       
   277 	TTime tempTime=file.Modified();
       
   278 	fileTimeToTime(info.iModified, tempTime, info.iTimeType);
       
   279 	file.SetModified(tempTime);
       
   280 	}
       
   281 
       
   282 void CSVPHostMountCB::DirOpenL(const TDesC& aName ,CDirCB* aDir)
       
   283 	{
       
   284 	DP(_L("CFatMountCB::DirOpenL, drv:%d, %S"), DriveNumber(), &aName);
       
   285 	CSVPHostDirCB& dir=(*((CSVPHostDirCB*)aDir));
       
   286 
       
   287 	TBuf<KMaxPath> name;
       
   288 	TUint driveNumber = Drive().DriveNumber();
       
   289 	CanonicalizePathname(aName, driveNumber, name);
       
   290 	TSVPHostFsDirOpenInfo info(driveNumber, name);
       
   291 	TInt err = SVP_HOST_FS_DEVICE().DirOpen(info);
       
   292 
       
   293 	User::LeaveIfError(err);
       
   294 
       
   295 	dir.SetHandle(info.iHandle);
       
   296 	TFileName n(TDriveUnit(Drive().DriveNumber()).Name());
       
   297 	n.Append(aName);
       
   298 	dir.SetFullName(n);
       
   299 	}
       
   300 
       
   301 void CSVPHostMountCB::RawReadL(TInt64 /*aPos*/,TInt /*aLength*/,const TAny* /*aTrg*/,TInt /*anOffset*/,const RMessagePtr2& /*aMessage*/) const
       
   302 	{
       
   303         DP(_L("** (SVPHOSTMNT) CSVPHostMountCB::RawReadL()"));
       
   304 	User::Leave(KErrNotSupported);
       
   305 	}
       
   306 
       
   307 void CSVPHostMountCB::RawWriteL(TInt64 /*aPos*/,TInt /*aLength*/,const TAny* /*aSrc*/,TInt /*anOffset*/,const RMessagePtr2& /*aMessage*/)
       
   308 	{
       
   309         DP(_L("** (SVPHOSTMNT) CSVPHostMountCB::RawWriteL()"));
       
   310 	User::Leave(KErrNotSupported);
       
   311 	}
       
   312 
       
   313 void CSVPHostMountCB::GetShortNameL(const TDesC& aLongName,TDes& aShortName)
       
   314 	{
       
   315 	DP(_L("** (SVPHOSTMNT) CSVPHostMountCB::GetShortNameL(%S)"), &aLongName);
       
   316 	aShortName = aLongName;
       
   317 	}
       
   318 
       
   319 void CSVPHostMountCB::GetLongNameL(const TDesC& aShortName,TDes& aLongName)
       
   320 	{
       
   321 	DP(_L("** (SVPHOSTMNT) CSVPHostMountCB::GetLongNameL(%S)"), &aShortName);
       
   322 	aLongName = aShortName;
       
   323 	}
       
   324 
       
   325 void CSVPHostMountCB::ReadSectionL(const TDesC& /*aName*/,TInt /*aPos*/,TAny* /*aTrg*/,TInt /*aLength*/,const RMessagePtr2& /*aMessage*/)
       
   326 	{
       
   327         DP(_L("** (SVPHOSTMNT) CSVPHostMountCB::RawSectionL()"));
       
   328 	User::Leave(KErrNotSupported);
       
   329 	}
       
   330 
       
   331 TBool CSVPHostMountCB::IsRomDrive() const
       
   332 	{
       
   333         DP(_L("** (SVPHOSTMNT) CSVPHostMountCB::IsRomDrive()"));
       
   334 	return(EFalse);
       
   335 	}