|
0
|
1 |
// Copyright (c) 1995-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_svr.cpp
|
|
|
15 |
//
|
|
|
16 |
//
|
|
|
17 |
|
|
|
18 |
#include "sf_std.h"
|
|
|
19 |
#include "sf_cache_man.h"
|
|
|
20 |
#include "sf_file_cache.h"
|
|
|
21 |
#include "sf_memory_man.h"
|
|
|
22 |
|
|
|
23 |
TInt DoFsSubClose(CFsRequest* aRequest)
|
|
|
24 |
//
|
|
|
25 |
// Close a subsession.
|
|
|
26 |
//
|
|
|
27 |
{
|
|
|
28 |
const TInt handle(aRequest->Message().Int3());
|
|
|
29 |
|
|
|
30 |
CFsObject* pO=SessionObjectFromHandle(handle,0,aRequest->Session());
|
|
|
31 |
if(!pO)
|
|
|
32 |
return KErrBadHandle;
|
|
|
33 |
|
|
|
34 |
aRequest->Session()->DecResourceCount();
|
|
|
35 |
aRequest->Session()->Handles().Remove(handle,ETrue);
|
|
|
36 |
|
|
|
37 |
// this request has also opened this object, so close it here before it
|
|
|
38 |
// gets to a plugin as a plugin may attempt to open the file/dir itself
|
|
|
39 |
aRequest->SetScratchValue64( MAKE_TUINT64(I64HIGH(aRequest->ScratchValue64()), 0));
|
|
|
40 |
|
|
|
41 |
return(KErrNone);
|
|
|
42 |
}
|
|
|
43 |
|
|
|
44 |
|
|
|
45 |
TInt TFsSubClose::DoRequestL(CFsRequest* aRequest)
|
|
|
46 |
//
|
|
|
47 |
// Close a subsession.
|
|
|
48 |
//
|
|
|
49 |
{
|
|
|
50 |
|
|
|
51 |
// Leave and then panic client with KErrBadHandle if necessary.
|
|
|
52 |
CFsObject* pO = SessionObjectFromHandle(aRequest->Message().Int3(),0,aRequest->Session());
|
|
|
53 |
if(!pO)
|
|
|
54 |
return KErrBadHandle;
|
|
|
55 |
|
|
|
56 |
if(aRequest->Message().Function() == EFsFileSubClose)
|
|
|
57 |
{
|
|
|
58 |
CFileShare* pShare = (CFileShare*) aRequest->ScratchValue();
|
|
|
59 |
|
|
|
60 |
// flush the file cache
|
|
|
61 |
CFileCache* fileCache = pShare->File().FileCache();
|
|
|
62 |
if (fileCache && fileCache->FlushDirty(aRequest) == CFsRequest::EReqActionBusy)
|
|
|
63 |
return CFsRequest::EReqActionBusy;
|
|
|
64 |
|
|
|
65 |
// if any write requests are being fair scheduled, wait for them to complete
|
|
|
66 |
if (pShare->RequestInProgress())
|
|
|
67 |
return CFsRequest::EReqActionBusy;
|
|
|
68 |
}
|
|
|
69 |
|
|
|
70 |
return DoFsSubClose(aRequest);
|
|
|
71 |
}
|
|
|
72 |
|
|
|
73 |
TInt TFsSubClose::Initialise(CFsRequest* aRequest)
|
|
|
74 |
//
|
|
|
75 |
// Now moved to RequestAllocator::GetRequest
|
|
|
76 |
//
|
|
|
77 |
{
|
|
|
78 |
TInt r = KErrNone;
|
|
|
79 |
// Closing a file share may require flushing of dirty data, so deal with this in the drive thread
|
|
|
80 |
// in TFsSubClose::DoRequestL(). For other objects (EFsFormatSubClose, EFsDirSubClose, EFsRawSubClose,
|
|
|
81 |
// FsPluginSubClose) we may complete the message here.
|
|
|
82 |
if(aRequest->FsFunction() == EFsFileSubClose)
|
|
|
83 |
{
|
|
|
84 |
CFileShare* pShare = (CFileShare*)
|
|
|
85 |
SessionObjectFromHandle(aRequest->Message().Int3(), FileShares->UniqueID(), aRequest->Session());
|
|
|
86 |
|
|
|
87 |
if(!pShare)
|
|
|
88 |
User::Leave(KErrBadHandle);
|
|
|
89 |
|
|
|
90 |
HBufC* pFileName = pShare->File().FileName().Alloc();
|
|
|
91 |
aRequest->SetScratchValue64( MAKE_TUINT64((TUint) pFileName, (TUint) pShare) );
|
|
|
92 |
TInt driveNumber = pShare->File().Drive().DriveNumber();
|
|
|
93 |
aRequest->SetDriveNumber(driveNumber);
|
|
|
94 |
}
|
|
|
95 |
|
|
|
96 |
// Define a completion routine so that we can see whether this request is cancelled -
|
|
|
97 |
// if it is we still want to close the subsession (but not bother about flushing dirty data)
|
|
|
98 |
r = ((CFsMessageRequest*) aRequest)->PushOperation(TFsSubClose::Complete);
|
|
|
99 |
|
|
|
100 |
|
|
|
101 |
|
|
|
102 |
return r;
|
|
|
103 |
}
|
|
|
104 |
|
|
|
105 |
TInt TFsSubClose::Complete(CFsRequest* aRequest)
|
|
|
106 |
{
|
|
|
107 |
// if LastError() != KErrNone, this implies the request has been cancelled.
|
|
|
108 |
// i.e. TFsSubClose::DoRequestL() has not been called, so we need to call DoFsSubClose() here
|
|
|
109 |
if (((CFsMessageRequest*) aRequest)->LastError() != KErrNone)
|
|
|
110 |
DoFsSubClose(aRequest);
|
|
|
111 |
|
|
|
112 |
return CFsRequest::EReqActionComplete;
|
|
|
113 |
}
|
|
|
114 |
|
|
|
115 |
|
|
|
116 |
TInt TFsNotifyChange::DoRequestL(CFsRequest* aRequest)
|
|
|
117 |
//
|
|
|
118 |
//
|
|
|
119 |
//
|
|
|
120 |
{
|
|
|
121 |
CStdChangeInfo* notificationInfo=new CStdChangeInfo;
|
|
|
122 |
if (notificationInfo==NULL)
|
|
|
123 |
return (KErrNoMemory);
|
|
|
124 |
const RMessage2& m=aRequest->Message();
|
|
|
125 |
notificationInfo->Initialise((TNotifyType)m.Int0(),(TRequestStatus*)m.Ptr1(),m,aRequest->Session());
|
|
|
126 |
TInt r=FsNotify::AddChange(notificationInfo,KDriveInvalid);
|
|
|
127 |
if(r!=KErrNone)
|
|
|
128 |
delete(notificationInfo);
|
|
|
129 |
return(r);
|
|
|
130 |
}
|
|
|
131 |
|
|
|
132 |
|
|
|
133 |
TInt TFsNotifyChange::Initialise(CFsRequest* /*aRequest*/)
|
|
|
134 |
//
|
|
|
135 |
//
|
|
|
136 |
//
|
|
|
137 |
{
|
|
|
138 |
return(KErrNone);
|
|
|
139 |
}
|
|
|
140 |
|
|
|
141 |
TInt TFsNotifyChangeEx::DoRequestL(CFsRequest* aRequest)
|
|
|
142 |
//
|
|
|
143 |
// Set up an extended change notification
|
|
|
144 |
//
|
|
|
145 |
{
|
|
|
146 |
TUint notifyType=aRequest->Message().Int0();
|
|
|
147 |
if (aRequest->Src().NamePresent()) // Monitoring a file
|
|
|
148 |
{ // Reject if iNotifyType is ENotifyDir
|
|
|
149 |
if (notifyType&ENotifyDir)
|
|
|
150 |
return (KErrArgument);
|
|
|
151 |
}
|
|
|
152 |
CExtChangeInfo* notificationInfo=new CExtChangeInfo;
|
|
|
153 |
if (notificationInfo==NULL)
|
|
|
154 |
return (KErrNoMemory);
|
|
|
155 |
/* TEntry t;
|
|
|
156 |
TInt ret=aRequest->Drive()->Entry(aRequest->Src().FullName().Mid(2),t);
|
|
|
157 |
if ((ret==KErrNotFound)||(ret==KErrPathNotFound)||(ret==KErrInUse))
|
|
|
158 |
// Path does not yet exist or drive has been locked - still submit request
|
|
|
159 |
// but mark it as notify all since the client is potentially interested
|
|
|
160 |
notifyType=ENotifyAll;
|
|
|
161 |
else if (ret!=KErrNone)
|
|
|
162 |
{
|
|
|
163 |
delete notificationInfo;
|
|
|
164 |
return(ret);
|
|
|
165 |
}*/
|
|
|
166 |
|
|
|
167 |
const RMessage2& m=aRequest->Message();
|
|
|
168 |
notificationInfo->Initialise((TNotifyType)notifyType,(TRequestStatus*)m.Ptr2(),m,aRequest->Session(),aRequest->Src().FullName().Mid(2));
|
|
|
169 |
TInt drive;
|
|
|
170 |
if (aRequest->ScratchValue()!=0)
|
|
|
171 |
drive=KDriveInvalid;
|
|
|
172 |
else
|
|
|
173 |
drive=aRequest->DriveNumber();
|
|
|
174 |
TInt ret=FsNotify::AddChange(notificationInfo,drive);
|
|
|
175 |
if(ret!=KErrNone)
|
|
|
176 |
delete(notificationInfo);
|
|
|
177 |
return(ret);
|
|
|
178 |
}
|
|
|
179 |
|
|
|
180 |
|
|
|
181 |
TInt TFsNotifyChangeEx::Initialise(CFsRequest* aRequest)
|
|
|
182 |
{
|
|
|
183 |
// Establish whether the directory or file to watch actually exists
|
|
|
184 |
// This sets the aSession members iTheName and iTheParse etc
|
|
|
185 |
TInt ret=KErrNone;
|
|
|
186 |
TBool monitorAllDrives=EFalse;
|
|
|
187 |
TFileName notifyPath;
|
|
|
188 |
|
|
|
189 |
TRAP(ret,aRequest->ReadL(KMsgPtr1,notifyPath));
|
|
|
190 |
if(ret!=KErrNone)
|
|
|
191 |
return(ret);
|
|
|
192 |
if(notifyPath.Length()==0)
|
|
|
193 |
return(KErrArgument);
|
|
|
194 |
|
|
|
195 |
if ((notifyPath[0]==KMatchAny)||(notifyPath[0]==KMatchOne))
|
|
|
196 |
{
|
|
|
197 |
// Use the default session drive for now
|
|
|
198 |
// Client has submitted a ? or * for drive
|
|
|
199 |
monitorAllDrives=ETrue;
|
|
|
200 |
ret=ParseNotificationPath(aRequest,aRequest->Src(),notifyPath);
|
|
|
201 |
if (ret!=KErrNone)
|
|
|
202 |
return(ret);
|
|
|
203 |
}
|
|
|
204 |
else
|
|
|
205 |
{
|
|
|
206 |
// Client has submitted a single drive to monitor
|
|
|
207 |
monitorAllDrives=EFalse;
|
|
|
208 |
|
|
|
209 |
ret = ParseNoWildSubstPtr1(aRequest, aRequest->Src());
|
|
|
210 |
if (ret!=KErrNone)
|
|
|
211 |
return(ret);
|
|
|
212 |
}
|
|
|
213 |
aRequest->SetScratchValue(monitorAllDrives);
|
|
299
|
214 |
ret = PathCheck(aRequest->Message(),aRequest->Src().FullName().Mid(2),&KCapFsNotifyChangeEx, __PLATSEC_DIAGNOSTIC_STRING("Extended Change Notifier"));
|
|
0
|
215 |
return(ret);
|
|
|
216 |
}
|
|
|
217 |
|
|
|
218 |
TInt TFsNotifyChangeCancel::DoRequestL(CFsRequest* aRequest)
|
|
|
219 |
//
|
|
|
220 |
//
|
|
|
221 |
//
|
|
|
222 |
{
|
|
|
223 |
FsNotify::CancelChangeSession(aRequest->Session());
|
|
|
224 |
#if defined(_DEBUG)
|
|
|
225 |
FsNotify::CancelDebugSession(aRequest->Session());
|
|
|
226 |
#endif
|
|
|
227 |
return(KErrNone);
|
|
|
228 |
}
|
|
|
229 |
|
|
|
230 |
|
|
|
231 |
|
|
|
232 |
TInt TFsNotifyChangeCancel::Initialise(CFsRequest* /*aRequest*/)
|
|
|
233 |
//
|
|
|
234 |
//
|
|
|
235 |
//
|
|
|
236 |
{
|
|
|
237 |
return KErrNone;
|
|
|
238 |
}
|
|
|
239 |
|
|
|
240 |
|
|
|
241 |
|
|
|
242 |
TInt TFsNotifyChangeCancelEx::DoRequestL(CFsRequest* aRequest)
|
|
|
243 |
//
|
|
|
244 |
//
|
|
|
245 |
//
|
|
|
246 |
{
|
|
|
247 |
FsNotify::CancelChangeSession(aRequest->Session(),(TRequestStatus*)aRequest->Message().Ptr0());
|
|
|
248 |
#if defined(_DEBUG) || defined(_DEBUG_RELEASE)
|
|
|
249 |
FsNotify::CancelDebugSession(aRequest->Session());
|
|
|
250 |
#endif
|
|
|
251 |
return(KErrNone);
|
|
|
252 |
}
|
|
|
253 |
|
|
|
254 |
|
|
|
255 |
|
|
|
256 |
TInt TFsNotifyChangeCancelEx::Initialise(CFsRequest* /*aRequest*/)
|
|
|
257 |
//
|
|
|
258 |
//
|
|
|
259 |
//
|
|
|
260 |
{
|
|
|
261 |
return KErrNone;
|
|
|
262 |
}
|
|
|
263 |
|
|
|
264 |
//
|
|
|
265 |
// Setup a disk space notification request
|
|
|
266 |
//
|
|
|
267 |
TInt TFsNotifyDiskSpace::DoRequestL(CFsRequest *aRequest)
|
|
|
268 |
{
|
|
|
269 |
//-- first check that the threshold value is correct and is less than the volume size
|
|
|
270 |
const TUint64 threshold = aRequest->ScratchValue64();
|
|
|
271 |
if(threshold <= 0)
|
|
|
272 |
return KErrArgument;
|
|
|
273 |
|
|
|
274 |
//-- get the size of the mounted volume to check that the requested threshold isn't larger than the volume
|
|
|
275 |
TUint64 volSz;
|
|
|
276 |
TInt r = aRequest->Drive()->MountedVolumeSize(volSz);
|
|
|
277 |
if (r!=KErrNone)
|
|
|
278 |
return r;
|
|
|
279 |
|
|
|
280 |
if(threshold >= volSz)
|
|
|
281 |
return KErrArgument;
|
|
|
282 |
|
|
|
283 |
|
|
|
284 |
//-- Create the disk space notificator object and append it to the FsNotify queue
|
|
|
285 |
CDiskSpaceInfo* info=new CDiskSpaceInfo;
|
|
|
286 |
if(info==NULL)
|
|
|
287 |
return(KErrNoMemory);
|
|
|
288 |
|
|
|
289 |
const RMessage2& m=aRequest->Message();
|
|
|
290 |
info->Initialise((TRequestStatus*)m.Ptr2(),m,aRequest->Session(),threshold);
|
|
|
291 |
|
|
|
292 |
r=FsNotify::AddDiskSpace(info,aRequest->DriveNumber());
|
|
|
293 |
if(r!=KErrNone)
|
|
|
294 |
delete info;
|
|
|
295 |
|
|
|
296 |
return(r);
|
|
|
297 |
}
|
|
|
298 |
|
|
|
299 |
|
|
|
300 |
TInt TFsNotifyDiskSpace::Initialise(CFsRequest *aRequest)
|
|
|
301 |
//
|
|
|
302 |
//
|
|
|
303 |
//
|
|
|
304 |
{
|
|
|
305 |
TInt r=ValidateDriveDoSubst(aRequest->Message().Int1(),aRequest);
|
|
|
306 |
if (r==KErrNone)
|
|
|
307 |
{
|
|
|
308 |
TInt64 threshold;
|
|
|
309 |
TPtr8 tBuf((TUint8*)&threshold,sizeof(TInt64));
|
|
|
310 |
aRequest->ReadL(KMsgPtr0,tBuf);
|
|
|
311 |
aRequest->SetScratchValue64(threshold);
|
|
|
312 |
}
|
|
|
313 |
return(r);
|
|
|
314 |
}
|
|
|
315 |
|
|
|
316 |
TInt TFsNotifyDiskSpaceCancel::DoRequestL(CFsRequest *aRequest)
|
|
|
317 |
//
|
|
|
318 |
// Cancel disk space notification
|
|
|
319 |
//
|
|
|
320 |
{
|
|
|
321 |
FsNotify::CancelDiskSpaceSession(aRequest->Session(),(TRequestStatus*)aRequest->Message().Ptr0());
|
|
|
322 |
return(KErrNone);
|
|
|
323 |
}
|
|
|
324 |
|
|
|
325 |
|
|
|
326 |
TInt TFsNotifyDiskSpaceCancel::Initialise(CFsRequest* /*aRequest*/)
|
|
|
327 |
//
|
|
|
328 |
//
|
|
|
329 |
//
|
|
|
330 |
{
|
|
|
331 |
return(KErrNone);
|
|
|
332 |
}
|
|
|
333 |
|
|
|
334 |
TInt TFsSynchroniseDriveThread::DoRequestL(CFsRequest* /*aRequest*/)
|
|
|
335 |
//
|
|
|
336 |
// This is to ensure that previous message has been handled in drive thread.
|
|
|
337 |
//
|
|
|
338 |
{
|
|
|
339 |
return CFsRequest::EReqActionComplete;
|
|
|
340 |
}
|
|
|
341 |
|
|
|
342 |
TInt TFsSynchroniseDriveThread::Initialise(CFsRequest *aRequest)
|
|
|
343 |
//
|
|
|
344 |
// Set the drive thread.
|
|
|
345 |
//
|
|
|
346 |
{
|
|
|
347 |
if(aRequest->Message().Int0() == -1) //If no drive thread then complete the message
|
|
|
348 |
{
|
|
|
349 |
return CFsRequest::EReqActionComplete;
|
|
|
350 |
}
|
|
|
351 |
TInt r=ValidateDriveDoSubst(aRequest->Message().Int0(),aRequest);
|
|
|
352 |
return r;
|
|
|
353 |
}
|
|
|
354 |
|
|
|
355 |
#if defined(_DEBUG) || defined(_DEBUG_RELEASE)
|
|
|
356 |
EXPORT_C void DebugNotifySessions(TInt aFunction,TInt /*aDrive*/)
|
|
|
357 |
//
|
|
|
358 |
// Notify sessions of a debug event
|
|
|
359 |
//
|
|
|
360 |
{
|
|
|
361 |
// Notifying involves memory de-allocation on the file server's heap -
|
|
|
362 |
// check if we need to switch heaps.
|
|
|
363 |
RAllocator* current_alloc = &User::Heap();
|
|
|
364 |
RAllocator* svr_alloc = ServerThreadAllocator;
|
|
|
365 |
if (current_alloc != svr_alloc)
|
|
|
366 |
User::SwitchHeap(svr_alloc);
|
|
|
367 |
FsNotify::HandleDebug(aFunction);
|
|
|
368 |
if (current_alloc != svr_alloc)
|
|
|
369 |
User::SwitchHeap(current_alloc);
|
|
|
370 |
}
|
|
|
371 |
#else
|
|
|
372 |
EXPORT_C void DebugNotifySessions(TInt,TInt)
|
|
|
373 |
//
|
|
|
374 |
// Notify sessions of a debug event
|
|
|
375 |
//
|
|
|
376 |
{}
|
|
|
377 |
#endif
|
|
|
378 |
|
|
|
379 |
|
|
|
380 |
TInt TFsDriveList::DoRequestL(CFsRequest* aRequest)
|
|
|
381 |
//
|
|
|
382 |
// Get the current drive list.
|
|
|
383 |
//
|
|
|
384 |
{
|
|
|
385 |
TDriveList list(KMaxDrives);
|
|
|
386 |
|
|
|
387 |
const TUint mask = (TUint) aRequest->Message().Int1();
|
|
|
388 |
const TUint matchedFlags= mask & KDriveAttMatchedFlags; //KDriveAttMatchedFlags = 0xFFF
|
|
|
389 |
const TUint matchedAtt = mask & KDriveAttMatchedAtt; //KDriveAttMatchedAtt = 0x0FFF0000
|
|
|
390 |
|
|
|
391 |
TInt r = ValidateMatchMask(mask);
|
|
|
392 |
if(r!=KErrNone)
|
|
|
393 |
return r;
|
|
|
394 |
|
|
|
395 |
for (TInt i=0;i<KMaxDrives;i++)
|
|
|
396 |
{
|
|
|
397 |
if(RFs::IsValidDrive(i))
|
|
|
398 |
{
|
|
|
399 |
const TUint driveAtt= TheDrives[i].Att();
|
|
|
400 |
if(matchedFlags != 0 )
|
|
|
401 |
{
|
|
|
402 |
switch(matchedAtt)
|
|
|
403 |
{
|
|
|
404 |
case KDriveAttExclude :
|
|
|
405 |
{
|
|
|
406 |
list[i]= (driveAtt & matchedFlags ) ? (TUint8)0:(TUint8)driveAtt ;
|
|
|
407 |
break;
|
|
|
408 |
}
|
|
|
409 |
case 0:
|
|
|
410 |
{
|
|
|
411 |
list[i] = (driveAtt & matchedFlags) ? (TUint8)driveAtt:(TUint8)0 ;
|
|
|
412 |
break;
|
|
|
413 |
}
|
|
|
414 |
case KDriveAttExclusive :
|
|
|
415 |
{
|
|
|
416 |
if(matchedFlags != KDriveAttLogicallyRemovable)
|
|
|
417 |
{
|
|
|
418 |
list[i] = ((TUint8)driveAtt == matchedFlags) ? (TUint8)driveAtt:(TUint8)0;
|
|
|
419 |
}
|
|
|
420 |
else
|
|
|
421 |
{
|
|
|
422 |
list[i] = (driveAtt == (matchedFlags | KDriveAttRemovable)) ? (TUint8)driveAtt:(TUint8)0;
|
|
|
423 |
}
|
|
|
424 |
break;
|
|
|
425 |
}
|
|
|
426 |
case KDriveAttExclude | KDriveAttExclusive:
|
|
|
427 |
{
|
|
|
428 |
if(matchedFlags != KDriveAttLogicallyRemovable)
|
|
|
429 |
{
|
|
|
430 |
list[i] = ((TUint8)driveAtt == matchedFlags) ?(TUint8)0:(TUint8)driveAtt;
|
|
|
431 |
}
|
|
|
432 |
else
|
|
|
433 |
{
|
|
|
434 |
list[i] = (driveAtt == (matchedFlags | KDriveAttRemovable)) ? (TUint8)driveAtt:(TUint8)0;
|
|
|
435 |
}
|
|
|
436 |
break;
|
|
|
437 |
}
|
|
|
438 |
default:
|
|
|
439 |
{
|
|
|
440 |
return KErrArgument;
|
|
|
441 |
}
|
|
|
442 |
}
|
|
|
443 |
}
|
|
|
444 |
else //matchedFlags == 0
|
|
|
445 |
{
|
|
|
446 |
switch(matchedAtt)
|
|
|
447 |
{
|
|
|
448 |
case 0:
|
|
|
449 |
list[i] = (TUint8)0 ;
|
|
|
450 |
break;
|
|
|
451 |
case KDriveAttAll:
|
|
|
452 |
list[i]= (TUint8)driveAtt;
|
|
|
453 |
break;
|
|
|
454 |
default: //all other cases are incorrect
|
|
|
455 |
return KErrArgument;
|
|
|
456 |
}
|
|
|
457 |
}
|
|
|
458 |
}
|
|
|
459 |
else //r!=KErrNone
|
|
|
460 |
{
|
|
|
461 |
list[i]=0;
|
|
|
462 |
}
|
|
|
463 |
}
|
|
|
464 |
|
|
|
465 |
aRequest->WriteL(KMsgPtr0,list);
|
|
|
466 |
|
|
|
467 |
// Finally, kick off a speculative probe for devices
|
|
|
468 |
ProxyDrives->Lock();
|
|
|
469 |
TInt idx = ProxyDrives->Count();
|
|
|
470 |
while(idx--)
|
|
|
471 |
{
|
|
|
472 |
CExtProxyDriveFactory* pF = (CExtProxyDriveFactory*)(*ProxyDrives)[idx];
|
|
|
473 |
if(pF)
|
|
|
474 |
{
|
|
|
475 |
pF->AsyncEnumerate();
|
|
|
476 |
}
|
|
|
477 |
}
|
|
|
478 |
ProxyDrives->Unlock();
|
|
|
479 |
|
|
|
480 |
return(KErrNone);
|
|
|
481 |
}
|
|
|
482 |
|
|
|
483 |
TInt TFsDriveList::Initialise(CFsRequest* /*aRequest*/)
|
|
|
484 |
//
|
|
|
485 |
//
|
|
|
486 |
//
|
|
|
487 |
{
|
|
|
488 |
return KErrNone;
|
|
|
489 |
}
|
|
|
490 |
|
|
|
491 |
TInt TFsDrive::DoRequestL(CFsRequest* aRequest)
|
|
|
492 |
//
|
|
|
493 |
// Get drive info.
|
|
|
494 |
//
|
|
|
495 |
{
|
|
|
496 |
// executed in main thread, therefore lock to ensure that
|
|
|
497 |
// dismount cannot occur during request
|
|
|
498 |
FsThreadManager::LockDrive(aRequest->DriveNumber());
|
|
|
499 |
TDriveInfo info;
|
|
|
500 |
aRequest->Drive()->DriveInfo(info);
|
|
|
501 |
if(aRequest->SubstedDrive())
|
|
|
502 |
info.iDriveAtt=KDriveAttSubsted;
|
|
|
503 |
FsThreadManager::UnlockDrive(aRequest->DriveNumber());
|
|
|
504 |
TPckgC<TDriveInfo> pInfo(info);
|
|
|
505 |
aRequest->WriteL(KMsgPtr0,pInfo);
|
|
|
506 |
return(KErrNone);
|
|
|
507 |
}
|
|
|
508 |
|
|
|
509 |
TInt TFsDrive::Initialise(CFsRequest* aRequest)
|
|
|
510 |
//
|
|
|
511 |
//
|
|
|
512 |
//
|
|
|
513 |
{
|
|
|
514 |
TInt r=ValidateDriveDoSubst(aRequest->Message().Int1(),aRequest);
|
|
|
515 |
return(r);
|
|
|
516 |
}
|
|
|
517 |
|
|
|
518 |
|
|
|
519 |
/**
|
|
|
520 |
Get volume info.
|
|
|
521 |
*/
|
|
|
522 |
TInt TFsVolume::DoRequestL(CFsRequest* aRequest)
|
|
|
523 |
{
|
|
|
524 |
TVolumeInfo v;
|
|
|
525 |
TPckg<TVolumeInfo> pV(v);
|
|
|
526 |
|
|
|
527 |
//-- read TVolumeInfo from the client side, the client may have provided some data to pass to the server and FSY side
|
|
|
528 |
aRequest->ReadL(KMsgPtr0,pV);
|
|
|
529 |
|
|
|
530 |
TRequestStatus* pStat = (TRequestStatus*)aRequest->Message().Ptr2();
|
|
|
531 |
if(pStat)
|
|
|
532 |
{//-- the user called an asynchronous version of the RFs::Volume
|
|
|
533 |
//-- indicate that we request free space asynchronously by setting a special flag that we will pass to the FSY
|
|
|
534 |
v.iVolSizeAsync = ETrue;
|
|
|
535 |
//-- at present the user's request will be completed by file server as the result of TFsVolume operation.
|
|
|
536 |
}
|
|
|
537 |
else
|
|
|
538 |
{
|
|
|
539 |
v.iVolSizeAsync = EFalse;
|
|
|
540 |
}
|
|
|
541 |
|
|
|
542 |
//-- ask the FSY to provide us its volume information
|
|
|
543 |
TInt r=aRequest->Drive()->Volume(v);
|
|
|
544 |
|
|
|
545 |
CSessionFs* session=aRequest->Session();
|
|
|
546 |
if (r==KErrNone)
|
|
|
547 |
{
|
|
|
548 |
TDrive* drive = aRequest->Drive();
|
|
|
549 |
const TInt driveNumber = drive->DriveNumber();
|
|
|
550 |
|
|
|
551 |
if(!session->ReservedAccess(driveNumber))
|
|
|
552 |
{
|
|
|
553 |
const TInt reserve = drive->ReservedSpace();
|
|
|
554 |
if(v.iFree <= reserve)
|
|
|
555 |
v.iFree = 0;
|
|
|
556 |
else
|
|
|
557 |
v.iFree -= reserve;
|
|
|
558 |
}
|
|
|
559 |
|
|
|
560 |
if(aRequest->SubstedDrive())
|
|
|
561 |
v.iDrive.iDriveAtt=KDriveAttSubsted;
|
|
|
562 |
|
|
|
563 |
|
|
|
564 |
|
|
|
565 |
if (drive->IsMounted() && drive->CurrentMount().LocalBufferSupport() == KErrNone && CCacheManagerFactory::CacheManager() != NULL)
|
|
|
566 |
v.iFileCacheFlags = TFileCacheSettings::Flags(driveNumber);
|
|
|
567 |
else
|
|
|
568 |
v.iFileCacheFlags = TFileCacheFlags(0);
|
|
|
569 |
|
|
|
570 |
|
|
|
571 |
aRequest->WriteL(KMsgPtr0,pV);
|
|
|
572 |
}
|
|
|
573 |
|
|
|
574 |
return(r);
|
|
|
575 |
}
|
|
|
576 |
|
|
|
577 |
TInt TFsVolume::Initialise(CFsRequest* aRequest)
|
|
|
578 |
//
|
|
|
579 |
//
|
|
|
580 |
//
|
|
|
581 |
{
|
|
|
582 |
|
|
|
583 |
TInt r=ValidateDriveDoSubst(aRequest->Message().Int1(),aRequest);
|
|
|
584 |
return(r);
|
|
|
585 |
}
|
|
|
586 |
|
|
|
587 |
|
|
|
588 |
TInt TFsSetVolume::DoRequestL(CFsRequest* aRequest)
|
|
|
589 |
//
|
|
|
590 |
// Set the volume name.
|
|
|
591 |
//
|
|
|
592 |
{
|
|
132
|
593 |
TInt r = CheckDiskSpace(KMinFsCreateObjTreshold, aRequest);
|
|
0
|
594 |
if(r != KErrNone)
|
|
|
595 |
return r;
|
|
|
596 |
|
|
|
597 |
// Validate name - return KErrBadName if it contains illegal characters such as * ? / | > <
|
|
299
|
598 |
TPtrC volumeName(aRequest->Dest().FullName());
|
|
|
599 |
TNameChecker checker(volumeName);
|
|
0
|
600 |
TText badChar;
|
|
|
601 |
if (checker.IsIllegalName(badChar))
|
|
|
602 |
return(KErrBadName);
|
|
|
603 |
|
|
|
604 |
return(aRequest->Drive()->SetVolume(volumeName));
|
|
|
605 |
}
|
|
|
606 |
|
|
|
607 |
|
|
|
608 |
TInt TFsSetVolume::Initialise(CFsRequest* aRequest)
|
|
|
609 |
//
|
|
|
610 |
//
|
|
|
611 |
//
|
|
|
612 |
{
|
|
|
613 |
TInt r=ValidateDriveDoSubst(aRequest->Message().Int1(),aRequest);
|
|
|
614 |
if (r!=KErrNone)
|
|
|
615 |
return(r);
|
|
299
|
616 |
TFileName volumeName;
|
|
|
617 |
TRAP(r,aRequest->ReadL(KMsgPtr0,volumeName));
|
|
|
618 |
if(r!=KErrNone)
|
|
|
619 |
return r;
|
|
|
620 |
if (volumeName.Length()>KMaxVolumeNameLength) // KMaxVolumeNameLength = 11
|
|
|
621 |
return(KErrBadName);
|
|
|
622 |
|
|
|
623 |
r = aRequest->Dest().Set(volumeName,NULL,NULL);
|
|
|
624 |
if(r!=KErrNone)
|
|
|
625 |
return r;
|
|
|
626 |
|
|
0
|
627 |
if (!KCapFsSetVolume.CheckPolicy(aRequest->Message(), __PLATSEC_DIAGNOSTIC_STRING("Set Volume")))
|
|
|
628 |
return KErrPermissionDenied;
|
|
|
629 |
return KErrNone;
|
|
|
630 |
}
|
|
|
631 |
|
|
|
632 |
|
|
|
633 |
TInt TFsSubst::DoRequestL(CFsRequest* aRequest)
|
|
|
634 |
//
|
|
|
635 |
// Get a drive substitution.
|
|
|
636 |
//
|
|
|
637 |
{
|
|
|
638 |
TInt r=ValidateDrive(aRequest->Message().Int1(),aRequest);
|
|
|
639 |
if(r!=KErrNone)
|
|
|
640 |
return(r);
|
|
|
641 |
TFileName substName;
|
|
|
642 |
__PRINT(_L("aRequest->Drive()->Att()&KDriveAttSubsted"));
|
|
|
643 |
__PRINT1(_L("aRequest->Drive()->Subst()"),&aRequest->Drive()->Subst());
|
|
|
644 |
if (aRequest->Drive()->IsSubsted())
|
|
|
645 |
substName=aRequest->Drive()->Subst();
|
|
|
646 |
aRequest->WriteL(KMsgPtr0,substName);
|
|
|
647 |
return(KErrNone);
|
|
|
648 |
}
|
|
|
649 |
|
|
|
650 |
|
|
|
651 |
TInt TFsSubst::Initialise(CFsRequest* /*aRequest*/)
|
|
|
652 |
//
|
|
|
653 |
//
|
|
|
654 |
//
|
|
|
655 |
{
|
|
|
656 |
return KErrNone;
|
|
|
657 |
}
|
|
|
658 |
|
|
|
659 |
|
|
|
660 |
TInt TFsSetSubst::DoRequestL(CFsRequest* aRequest)
|
|
|
661 |
//
|
|
|
662 |
// Set a drive substitution.
|
|
|
663 |
//
|
|
|
664 |
{
|
|
|
665 |
TInt r=ValidateDrive(aRequest->Message().Int1(),aRequest);
|
|
|
666 |
if (r!=KErrNone)
|
|
|
667 |
return(r);
|
|
|
668 |
TDrive* pD=aRequest->Drive();
|
|
|
669 |
r=ParsePathPtr0(aRequest,aRequest->Src());
|
|
|
670 |
if (r!=KErrNone)
|
|
|
671 |
return(r);
|
|
|
672 |
//TODO: no protection for unsubsting drives (could check substed path if system then only CRoot process can unsubst
|
|
|
673 |
if (pD->IsSubsted() && !aRequest->Src().DrivePresent() && !aRequest->Src().PathPresent())
|
|
|
674 |
{
|
|
|
675 |
delete &pD->Subst();
|
|
|
676 |
pD->SetSubst(NULL);
|
|
|
677 |
pD->SetAtt(0);
|
|
|
678 |
pD->SetSubstedDrive(NULL);
|
|
|
679 |
return(KErrNone);
|
|
|
680 |
}
|
|
299
|
681 |
r=PathCheck(aRequest->Message(),aRequest->Src().FullName().Mid(2),&KCapFsSysSetSubst,&KCapFsPriSetSubst,&KCapFsROSetSubst, __PLATSEC_DIAGNOSTIC_STRING("Set Subst"));
|
|
0
|
682 |
if (r!=KErrNone)
|
|
|
683 |
return(r);
|
|
|
684 |
if (pD->Att()&(KDriveAttLocal|KDriveAttRom|KDriveAttRedirected|KDriveAttSubsted))
|
|
|
685 |
return(KErrGeneral);
|
|
|
686 |
if (pD==aRequest->Drive())
|
|
|
687 |
return(KErrGeneral);
|
|
|
688 |
if (aRequest->Drive()->Att()&(KDriveAttRedirected|KDriveAttSubsted))
|
|
|
689 |
return(KErrInUse);
|
|
|
690 |
HBufC* pS=aRequest->Src().FullName().Alloc();
|
|
|
691 |
if (pS==NULL)
|
|
|
692 |
return(KErrNoMemory);
|
|
|
693 |
__ASSERT_DEBUG(!&pD->SubstedDrive(),Fault(ETFsSetSubstNotNull));
|
|
|
694 |
delete &pD->Subst();
|
|
|
695 |
pD->SetSubst(pS);
|
|
|
696 |
pD->SetSubstedDrive(aRequest->Drive());
|
|
|
697 |
pD->SetAtt(KDriveAttSubsted);
|
|
|
698 |
return(KErrNone);
|
|
|
699 |
}
|
|
|
700 |
|
|
|
701 |
TInt TFsSetSubst::Initialise(CFsRequest* aRequest)
|
|
|
702 |
//
|
|
|
703 |
//
|
|
|
704 |
//
|
|
|
705 |
{
|
|
|
706 |
if (!KCapFsSetSubst.CheckPolicy(aRequest->Message(),__PLATSEC_DIAGNOSTIC_STRING("Set subst")))
|
|
|
707 |
return KErrPermissionDenied;
|
|
|
708 |
return KErrNone;
|
|
|
709 |
}
|
|
|
710 |
|
|
|
711 |
|
|
|
712 |
TInt TFsRealName::DoRequestL(CFsRequest* aRequest)
|
|
|
713 |
//
|
|
|
714 |
// Get the real name of a file.
|
|
|
715 |
//
|
|
|
716 |
{
|
|
|
717 |
TInt r=ParseSubstPtr0(aRequest,aRequest->Src());
|
|
|
718 |
if (r!=KErrNone)
|
|
|
719 |
return(r);
|
|
299
|
720 |
r=PathCheck(aRequest->Message(),aRequest->Src().FullName().Mid(2),&KCapFsSysRealName,&KCapFsPriRealName, __PLATSEC_DIAGNOSTIC_STRING("Real Name"));
|
|
0
|
721 |
if (r!=KErrNone)
|
|
|
722 |
return(r);
|
|
|
723 |
TFileName substName;
|
|
|
724 |
if (aRequest->Drive()->Att()&KDriveAttRedirected)
|
|
|
725 |
substName=aRequest->Drive()->Subst(); // DANGER?
|
|
|
726 |
else
|
|
|
727 |
substName=aRequest->Src().Drive();
|
|
|
728 |
if ((substName.Length()+aRequest->Src().FullName().Mid(2).Length())>KMaxFileName)
|
|
|
729 |
return(KErrBadName);
|
|
|
730 |
substName+=aRequest->Src().FullName().Mid(2);
|
|
|
731 |
aRequest->WriteL(KMsgPtr1,substName);
|
|
|
732 |
return(KErrNone);
|
|
|
733 |
}
|
|
|
734 |
|
|
|
735 |
TInt TFsRealName::Initialise(CFsRequest* /*aRequest*/)
|
|
|
736 |
//
|
|
|
737 |
//
|
|
|
738 |
//
|
|
|
739 |
{
|
|
|
740 |
return KErrNone;
|
|
|
741 |
}
|
|
|
742 |
|
|
|
743 |
TInt TFsDefaultPath::DoRequestL(CFsRequest* aRequest)
|
|
|
744 |
//
|
|
|
745 |
// Get the default path.
|
|
|
746 |
//
|
|
|
747 |
{
|
|
|
748 |
if(PlatSec::ConfigSetting(PlatSec::EPlatSecEnforcement))
|
|
|
749 |
return KErrNotSupported;
|
|
|
750 |
else if(PlatSec::ConfigSetting(PlatSec::EPlatSecDiagnotics))
|
|
|
751 |
{
|
|
|
752 |
//FIXME: to be remove the following when platform is fully secure
|
|
|
753 |
RThread tT;
|
|
|
754 |
TInt r=aRequest->Message().Client(tT,EOwnerThread);
|
|
|
755 |
if(r!=KErrNone)
|
|
|
756 |
return r;
|
|
|
757 |
RProcess tP;
|
|
|
758 |
r=tT.Process(tP);
|
|
|
759 |
if(r!=KErrNone)
|
|
|
760 |
{
|
|
|
761 |
tT.Close();
|
|
|
762 |
return r;
|
|
|
763 |
}
|
|
|
764 |
TName n;
|
|
|
765 |
n=tP.Name();
|
|
|
766 |
TInt b=n.Locate('[');
|
|
|
767 |
if (b>=0)
|
|
|
768 |
n.SetLength(b);
|
|
|
769 |
RDebug::Print(_L("**** API violation: %S should not use DefaultPath()\n"),&n);
|
|
|
770 |
tP.Close();
|
|
|
771 |
tT.Close();
|
|
|
772 |
//FIXME END
|
|
|
773 |
aRequest->WriteL(KMsgPtr0,TheDefaultPath);
|
|
|
774 |
return(KErrNone);
|
|
|
775 |
}
|
|
|
776 |
else
|
|
|
777 |
{
|
|
|
778 |
aRequest->WriteL(KMsgPtr0,TheDefaultPath);
|
|
|
779 |
return(KErrNone);
|
|
|
780 |
}
|
|
|
781 |
}
|
|
|
782 |
|
|
|
783 |
TInt TFsDefaultPath::Initialise(CFsRequest* /*aRequest*/)
|
|
|
784 |
//
|
|
|
785 |
//
|
|
|
786 |
//
|
|
|
787 |
{
|
|
|
788 |
return KErrNone;
|
|
|
789 |
}
|
|
|
790 |
|
|
|
791 |
TInt TFsSetDefaultPath::DoRequestL(CFsRequest* aRequest)
|
|
|
792 |
//
|
|
|
793 |
// Set the default path.
|
|
|
794 |
//
|
|
|
795 |
{
|
|
|
796 |
if(PlatSec::ConfigSetting(PlatSec::EPlatSecEnforcement))
|
|
|
797 |
return KErrNotSupported;
|
|
|
798 |
else if(PlatSec::ConfigSetting(PlatSec::EPlatSecDiagnotics))
|
|
|
799 |
{
|
|
|
800 |
//FIXME: to be remove the following when platform is fully secure
|
|
|
801 |
RThread tT;
|
|
|
802 |
TInt r=aRequest->Message().Client(tT,EOwnerThread);
|
|
|
803 |
if(r!=KErrNone)
|
|
|
804 |
return r;
|
|
|
805 |
RProcess tP;
|
|
|
806 |
r=tT.Process(tP);
|
|
|
807 |
if(r!=KErrNone)
|
|
|
808 |
{
|
|
|
809 |
tT.Close();
|
|
|
810 |
return r;
|
|
|
811 |
}
|
|
|
812 |
TName n;
|
|
|
813 |
n=tP.Name();
|
|
|
814 |
TInt b=n.Locate('[');
|
|
|
815 |
if (b>=0)
|
|
|
816 |
n.SetLength(b);
|
|
|
817 |
RDebug::Print(_L("**** API violation: %S should not use SetDefaultPath()\n"),&n);
|
|
|
818 |
tP.Close();
|
|
|
819 |
tT.Close();
|
|
|
820 |
//FIXME END
|
|
|
821 |
TParse parse;
|
|
|
822 |
/*TInt*/ r=ParsePathPtr0(aRequest,parse);
|
|
|
823 |
if (r!=KErrNone && r!=KErrInUse)
|
|
|
824 |
return(r);
|
|
|
825 |
if (IsIllegalFullName(parse.FullName()))
|
|
|
826 |
return(KErrBadName);
|
|
|
827 |
TheDefaultPath=parse.FullName();
|
|
|
828 |
return(KErrNone);
|
|
|
829 |
}
|
|
|
830 |
else
|
|
|
831 |
{
|
|
|
832 |
TParse parse;
|
|
|
833 |
TInt r=ParsePathPtr0(aRequest,parse);
|
|
|
834 |
if (r!=KErrNone && r!=KErrInUse)
|
|
|
835 |
return(r);
|
|
|
836 |
if (IsIllegalFullName(parse.FullName()))
|
|
|
837 |
return(KErrBadName);
|
|
|
838 |
TheDefaultPath=parse.FullName();
|
|
|
839 |
return(KErrNone);
|
|
|
840 |
}
|
|
|
841 |
}
|
|
|
842 |
|
|
|
843 |
|
|
|
844 |
TInt TFsSetDefaultPath::Initialise(CFsRequest* /*aRequest*/)
|
|
|
845 |
//
|
|
|
846 |
//
|
|
|
847 |
//
|
|
|
848 |
{
|
|
|
849 |
return KErrNone;
|
|
|
850 |
}
|
|
|
851 |
|
|
|
852 |
TInt TFsSessionPath::DoRequestL(CFsRequest* aRequest)
|
|
|
853 |
//
|
|
|
854 |
// Get the session path
|
|
|
855 |
//
|
|
|
856 |
{
|
|
|
857 |
aRequest->WriteL(KMsgPtr0,aRequest->Session()->Path());
|
|
|
858 |
return(KErrNone);
|
|
|
859 |
}
|
|
|
860 |
|
|
|
861 |
TInt TFsSessionPath::Initialise(CFsRequest* /*aRequest*/)
|
|
|
862 |
//
|
|
|
863 |
//
|
|
|
864 |
//
|
|
|
865 |
{
|
|
|
866 |
return KErrNone;
|
|
|
867 |
}
|
|
|
868 |
|
|
|
869 |
|
|
|
870 |
TInt TFsSetSessionPath::DoRequestL(CFsRequest* aRequest)
|
|
|
871 |
//
|
|
|
872 |
// Set the session path
|
|
|
873 |
//
|
|
|
874 |
{
|
|
|
875 |
TParse parse;
|
|
|
876 |
TInt r=ParsePathPtr0(aRequest,parse);
|
|
|
877 |
if (r!=KErrNone && r!=KErrInUse)
|
|
|
878 |
return(r);
|
|
299
|
879 |
r=PathCheck(aRequest->Message(),parse.FullName().Mid(2),&KCapFsSysSetSessionPath,&KCapFsPriSetSessionPath, __PLATSEC_DIAGNOSTIC_STRING("Set Session Path"));
|
|
0
|
880 |
if (r!=KErrNone)
|
|
|
881 |
return(r);
|
|
|
882 |
if (IsIllegalFullName(parse.FullName()))
|
|
|
883 |
return(KErrBadName);
|
|
|
884 |
HBufC* pP=parse.FullName().Alloc();
|
|
|
885 |
if (pP==NULL)
|
|
|
886 |
return(KErrNoMemory);
|
|
|
887 |
delete &aRequest->Session()->Path();
|
|
|
888 |
aRequest->Session()->SetPath(pP);
|
|
|
889 |
return(KErrNone);
|
|
|
890 |
}
|
|
|
891 |
|
|
|
892 |
TInt TFsSetSessionPath::Initialise(CFsRequest* /*aRequest*/)
|
|
|
893 |
//
|
|
|
894 |
//
|
|
|
895 |
//
|
|
|
896 |
{
|
|
|
897 |
return(KErrNone);
|
|
|
898 |
}
|
|
|
899 |
|
|
|
900 |
|
|
|
901 |
TInt TFsParse::DoRequestL(CFsRequest* aRequest)
|
|
|
902 |
//
|
|
|
903 |
// Parse a file name.
|
|
|
904 |
//
|
|
|
905 |
{
|
|
|
906 |
TFileName name;
|
|
|
907 |
aRequest->ReadL(KMsgPtr0,name);
|
|
|
908 |
TFileName rel;
|
|
|
909 |
if (aRequest->Message().Ptr1()!=NULL)
|
|
|
910 |
aRequest->ReadL(KMsgPtr1,rel);
|
|
|
911 |
TParse p;
|
|
|
912 |
TInt r=p.Set(name,&rel,&aRequest->Session()->Path());
|
|
|
913 |
if (r==KErrNone)
|
|
|
914 |
{
|
|
|
915 |
TPckgC<TParse> pP(p);
|
|
|
916 |
aRequest->WriteL(KMsgPtr2,pP);
|
|
|
917 |
}
|
|
|
918 |
return(r);
|
|
|
919 |
}
|
|
|
920 |
|
|
|
921 |
TInt TFsParse::Initialise(CFsRequest* /*aRequest*/)
|
|
|
922 |
//
|
|
|
923 |
//
|
|
|
924 |
//
|
|
|
925 |
{
|
|
|
926 |
return KErrNone;
|
|
|
927 |
}
|
|
|
928 |
|
|
|
929 |
TInt TFsReserveDriveSpace::DoRequestL(CFsRequest* aRequest)
|
|
|
930 |
//
|
|
|
931 |
// set reserved value to add to a drives reserved area
|
|
|
932 |
//
|
|
|
933 |
{
|
|
|
934 |
// extract request info
|
|
|
935 |
CSessionFs* session=aRequest->Session();
|
|
|
936 |
TDrive* drive = aRequest->Drive();
|
|
|
937 |
|
|
|
938 |
if(session->ReservedAccess(drive->DriveNumber()))
|
|
|
939 |
return KErrInUse;
|
|
|
940 |
|
|
|
941 |
const TInt reserve = aRequest->Message().Int1(); //-- bytes to reserve on the drive
|
|
|
942 |
|
|
|
943 |
// Check if requested reserve space is within the range
|
|
|
944 |
if(reserve > KMaxSessionDriveReserved || reserve < 0)
|
|
|
945 |
return KErrArgument;
|
|
|
946 |
|
|
|
947 |
const TInt64 threshold = reserve + drive->ReservedSpace(); //-- free bytes on the volume we actually need
|
|
|
948 |
|
|
|
949 |
TInt nRes = drive->RequestFreeSpaceOnMount(threshold);
|
|
|
950 |
if(nRes != KErrNone)
|
|
|
951 |
return nRes;
|
|
|
952 |
|
|
|
953 |
const TInt current = session->Reserved(drive->DriveNumber());
|
|
|
954 |
const TInt diff = reserve - current;
|
|
|
955 |
TInt drvReserved = drive->ReservedSpace();
|
|
|
956 |
if((drvReserved + diff) > KMaxTotalDriveReserved)
|
|
|
957 |
return KErrTooBig;
|
|
|
958 |
|
|
|
959 |
drvReserved += diff;
|
|
|
960 |
drive->SetReservedSpace(drvReserved);
|
|
|
961 |
return session->SetReserved(drive->DriveNumber(), reserve);
|
|
|
962 |
|
|
|
963 |
}
|
|
|
964 |
|
|
|
965 |
TInt TFsReserveDriveSpace::Initialise(CFsRequest* aRequest)
|
|
|
966 |
//
|
|
|
967 |
// Validate drive and set up the session parameters for request
|
|
|
968 |
//
|
|
|
969 |
{
|
|
|
970 |
// if (!KCapFsReserveDriveSpace.CheckPolicy(aRequest->Message(), __PLATSEC_DIAGNOSTIC_STRING("Reserve Drive Space")))
|
|
|
971 |
// return KErrPermissionDenied;
|
|
|
972 |
TInt drvNumber=aRequest->Message().Int1();
|
|
|
973 |
drvNumber=aRequest->Message().Int0();
|
|
|
974 |
TInt r=ValidateDrive(aRequest->Message().Int0(),aRequest);
|
|
|
975 |
return(r);
|
|
|
976 |
}
|
|
|
977 |
|
|
|
978 |
|
|
|
979 |
TInt TFsGetReserveAccess::DoRequestL(CFsRequest* aRequest)
|
|
|
980 |
//
|
|
|
981 |
// Get reserved access to a drives reserved area first checking that the session has first reserved some space
|
|
|
982 |
//
|
|
|
983 |
{
|
|
|
984 |
CSessionFs* session=aRequest->Session();
|
|
|
985 |
|
|
|
986 |
TInt size=session->Reserved(aRequest->Drive()->DriveNumber());
|
|
|
987 |
if(size <= 0)
|
|
|
988 |
return KErrPermissionDenied;
|
|
|
989 |
else
|
|
|
990 |
session->SetReservedAccess(aRequest->Drive()->DriveNumber(),ETrue);
|
|
|
991 |
return KErrNone;
|
|
|
992 |
}
|
|
|
993 |
|
|
|
994 |
TInt TFsGetReserveAccess::Initialise(CFsRequest* aRequest)
|
|
|
995 |
//
|
|
|
996 |
//
|
|
|
997 |
//
|
|
|
998 |
{
|
|
|
999 |
// if (!KCapFsGetReserveAccess.CheckPolicy(aRequest->Message(), __PLATSEC_DIAGNOSTIC_STRING("Get Reserve Access")))
|
|
|
1000 |
// return KErrPermissionDenied;
|
|
|
1001 |
TInt r=ValidateDrive(aRequest->Message().Int0(),aRequest);
|
|
|
1002 |
return(r);
|
|
|
1003 |
}
|
|
|
1004 |
|
|
|
1005 |
|
|
|
1006 |
TInt TFsReleaseReserveAccess::DoRequestL(CFsRequest* aRequest)
|
|
|
1007 |
//
|
|
|
1008 |
// Remove access for this session to the locked area for a given drive
|
|
|
1009 |
//
|
|
|
1010 |
{
|
|
|
1011 |
aRequest->Session()->SetReservedAccess(aRequest->Drive()->DriveNumber(),EFalse);
|
|
|
1012 |
return KErrNone;
|
|
|
1013 |
}
|
|
|
1014 |
|
|
|
1015 |
TInt TFsReleaseReserveAccess::Initialise(CFsRequest* aRequest)
|
|
|
1016 |
//
|
|
|
1017 |
//
|
|
|
1018 |
//
|
|
|
1019 |
{
|
|
|
1020 |
// if (!KCapFsReleaseReserveAccess.CheckPolicy(aRequest->Message(), __PLATSEC_DIAGNOSTIC_STRING("Release Reserve Access")))
|
|
|
1021 |
// return KErrPermissionDenied;
|
|
|
1022 |
TInt r=ValidateDrive(aRequest->Message().Int0(),aRequest);
|
|
|
1023 |
return(r);
|
|
|
1024 |
}
|
|
|
1025 |
|
|
|
1026 |
TInt TFsSetStartupConfiguration::DoRequestL(CFsRequest* aRequest)
|
|
|
1027 |
//
|
|
|
1028 |
// Configure file server according to command and parameters.
|
|
|
1029 |
//
|
|
|
1030 |
{
|
|
|
1031 |
TInt cmd = aRequest->Message().Int0();
|
|
|
1032 |
|
|
|
1033 |
switch (cmd)
|
|
|
1034 |
{
|
|
|
1035 |
case ELoaderPriority:
|
|
|
1036 |
// Set loader thread priority
|
|
|
1037 |
{
|
|
|
1038 |
TInt r;
|
|
|
1039 |
TFullName loaderFullName(RProcess().FullName());
|
|
|
1040 |
loaderFullName.Append(_L("::LoaderThread"));
|
|
|
1041 |
RThread loader;
|
|
|
1042 |
r = loader.Open(loaderFullName);
|
|
|
1043 |
if (r != KErrNone)
|
|
|
1044 |
return r;
|
|
|
1045 |
loader.SetPriority((TThreadPriority)aRequest->Message().Int1());
|
|
|
1046 |
loader.Close();
|
|
|
1047 |
}
|
|
|
1048 |
break;
|
|
|
1049 |
case ESetRugged:
|
|
|
1050 |
{
|
|
|
1051 |
TInt drive = aRequest->Message().Int1();
|
|
|
1052 |
TInt r = ValidateDrive(drive, aRequest);
|
|
|
1053 |
if (r != KErrNone)
|
|
|
1054 |
return r;
|
|
|
1055 |
TInt value = aRequest->Message().Int2();
|
|
|
1056 |
aRequest->Drive()->SetRugged(value);
|
|
|
1057 |
}
|
|
|
1058 |
break;
|
|
|
1059 |
default:
|
|
|
1060 |
return KErrArgument;
|
|
|
1061 |
}
|
|
|
1062 |
|
|
|
1063 |
return KErrNone;
|
|
|
1064 |
}
|
|
|
1065 |
|
|
|
1066 |
TInt TFsSetStartupConfiguration::Initialise(CFsRequest* aRequest)
|
|
|
1067 |
//
|
|
|
1068 |
// Check SID of message sender. Can be estart only
|
|
|
1069 |
//
|
|
|
1070 |
{
|
|
|
1071 |
if (aRequest->Message().SecureId() != KEstartUidValue)
|
|
|
1072 |
return KErrPermissionDenied;
|
|
|
1073 |
return KErrNone;
|
|
|
1074 |
}
|
|
|
1075 |
|
|
|
1076 |
|
|
|
1077 |
const TInt KinitialChanges = EChangesLocale|EChangesMidnightCrossover|EChangesThreadDeath|EChangesPowerStatus|EChangesSystemTime|EChangesFreeMemory|EChangesOutOfMemory;
|
|
|
1078 |
|
|
|
1079 |
CKernEventNotifier* CKernEventNotifier::New(TInt aPriority)
|
|
|
1080 |
{
|
|
|
1081 |
__PRINT(_L("CKernEventNotifier::New"));
|
|
|
1082 |
CKernEventNotifier* self = new CKernEventNotifier(aPriority);
|
|
|
1083 |
if (self && (self->iChangeNotifier.Create() != KErrNone))
|
|
|
1084 |
delete self, self = NULL;
|
|
|
1085 |
return self;
|
|
|
1086 |
}
|
|
|
1087 |
|
|
|
1088 |
CKernEventNotifier::~CKernEventNotifier()
|
|
|
1089 |
{
|
|
|
1090 |
Cancel();
|
|
|
1091 |
iChangeNotifier.Close();
|
|
|
1092 |
}
|
|
|
1093 |
|
|
|
1094 |
void CKernEventNotifier::Start()
|
|
|
1095 |
{
|
|
|
1096 |
SetActive();
|
|
|
1097 |
iChangeNotifier.Logon(iStatus);
|
|
|
1098 |
}
|
|
|
1099 |
|
|
|
1100 |
void CKernEventNotifier::RunL()
|
|
|
1101 |
{
|
|
|
1102 |
__PRINT(_L("CKernEventNotifier::RunL"));
|
|
|
1103 |
iChange = iStatus.Int();
|
|
|
1104 |
Start();
|
|
|
1105 |
|
|
|
1106 |
/* Avoid being triggered by initial events */
|
|
|
1107 |
if (iChange != 0 && (iChange & KinitialChanges) != KinitialChanges)
|
|
|
1108 |
{
|
|
|
1109 |
if (iChange & EChangesLocale)
|
|
|
1110 |
CKernEventNotifier::LocaleChangeCallback();
|
|
|
1111 |
if (iChange & EChangesFreeMemory)
|
|
|
1112 |
CKernEventNotifier::FreeMemoryChangeCallback();
|
|
|
1113 |
// Add other event capture below this line
|
|
|
1114 |
iChange = 0;
|
|
|
1115 |
}
|
|
|
1116 |
}
|
|
|
1117 |
|
|
|
1118 |
void CKernEventNotifier::DoCancel()
|
|
|
1119 |
{
|
|
|
1120 |
iChangeNotifier.LogonCancel();
|
|
|
1121 |
}
|
|
|
1122 |
|
|
|
1123 |
|
|
|
1124 |
extern TBool FatUtilitiesUpdateDrivesNotified;
|
|
|
1125 |
extern TBool FatUtilityFunctionsSet;
|
|
|
1126 |
|
|
|
1127 |
TInt CKernEventNotifier::LocaleChangeCallback(TAny*)
|
|
|
1128 |
{
|
|
|
1129 |
__PRINT(_L("CKernEventNotifier::LocaleChangeCallback"));
|
|
|
1130 |
|
|
|
1131 |
//-- check if the locale has just been set and the drives are not yet notified about this.
|
|
|
1132 |
if(FatUtilityFunctionsSet && !FatUtilitiesUpdateDrivesNotified)
|
|
|
1133 |
{//-- notify drives about locale shange, but only once
|
|
|
1134 |
for(TInt i=0; i<KMaxDrives; i++)
|
|
|
1135 |
{
|
|
|
1136 |
TDrive& drive=TheDrives[i];
|
|
|
1137 |
|
|
|
1138 |
if(drive.DriveNumber() >=0 && drive.IsRemovable() && !drive.IsSubsted())
|
|
|
1139 |
{
|
|
|
1140 |
__PRINT1(_L("CKernEventNotifier::LocaleChangeCallback upd drive: %d"), drive.DriveNumber());
|
|
|
1141 |
drive.SetChanged(ETrue);
|
|
|
1142 |
}
|
|
|
1143 |
}
|
|
|
1144 |
|
|
|
1145 |
FatUtilitiesUpdateDrivesNotified = ETrue;
|
|
|
1146 |
}
|
|
|
1147 |
|
|
|
1148 |
return KErrNone;
|
|
|
1149 |
}
|
|
|
1150 |
|
|
|
1151 |
TInt TFsQueryVolumeInfoExt::DoRequestL(CFsRequest* aRequest)
|
|
|
1152 |
{
|
|
|
1153 |
const TInt cmd = aRequest->Message().Int1();
|
|
|
1154 |
TInt rel;
|
|
|
1155 |
|
|
|
1156 |
TDrive* pDrive = aRequest->Drive();
|
|
|
1157 |
|
|
|
1158 |
rel = pDrive->CheckMount();
|
|
|
1159 |
if(rel != KErrNone)
|
|
|
1160 |
return rel;
|
|
|
1161 |
|
|
|
1162 |
switch (cmd)
|
|
|
1163 |
{
|
|
|
1164 |
|
|
|
1165 |
//-------------------------------------------------
|
|
|
1166 |
//-- file system sub type query
|
|
|
1167 |
case EFileSystemSubType:
|
|
|
1168 |
{
|
|
|
1169 |
TFSName name;
|
|
|
1170 |
if (pDrive->IsMounted())
|
|
|
1171 |
{
|
|
|
1172 |
rel = pDrive->CurrentMount().FileSystemSubType(name);
|
|
|
1173 |
|
|
|
1174 |
//-- get the Mount's file system name if the FS subtype query is not supported or there are no subtypes.
|
|
|
1175 |
if (rel==KErrNotSupported)
|
|
|
1176 |
{
|
|
|
1177 |
pDrive->CurrentMount().FileSystemName(name);
|
|
|
1178 |
}
|
|
|
1179 |
|
|
|
1180 |
if (name.Length())
|
|
|
1181 |
{
|
|
|
1182 |
TPckgBuf<TFSName> pckgBuf(name);
|
|
|
1183 |
aRequest->WriteL(KMsgPtr2, pckgBuf);
|
|
|
1184 |
return KErrNone;
|
|
|
1185 |
}
|
|
|
1186 |
else
|
|
|
1187 |
{
|
|
|
1188 |
return rel;
|
|
|
1189 |
}
|
|
|
1190 |
}
|
|
|
1191 |
else
|
|
|
1192 |
{
|
|
|
1193 |
return KErrNotReady;
|
|
|
1194 |
}
|
|
|
1195 |
}
|
|
|
1196 |
|
|
|
1197 |
|
|
|
1198 |
//-------------------------------------------------
|
|
|
1199 |
//-- this is RFs::VolumeIOParam() query
|
|
|
1200 |
case EIOParamInfo:
|
|
|
1201 |
{
|
|
|
1202 |
TVolumeIOParamInfo ioInfo;
|
|
|
1203 |
// 1. gets block size information via media driver
|
|
|
1204 |
const TInt drive = aRequest->Message().Int0();
|
|
|
1205 |
|
|
|
1206 |
// validates local drive numbers
|
|
|
1207 |
if(!IsValidLocalDriveMapping(drive))
|
|
|
1208 |
{
|
|
|
1209 |
ioInfo.iBlockSize = KErrNotReady;
|
|
|
1210 |
}
|
|
|
1211 |
else
|
|
|
1212 |
{
|
|
|
1213 |
// Get media capability
|
|
|
1214 |
TLocalDriveCapsV6Buf capsBuf;
|
|
|
1215 |
|
|
|
1216 |
// is the drive local?
|
|
|
1217 |
if (!IsProxyDrive(drive))
|
|
|
1218 |
{
|
|
|
1219 |
// if not valid local drive, use default values in localDriveCaps
|
|
|
1220 |
// if valid local drive and not locked, use TBusLocalDrive::Caps() values
|
|
|
1221 |
// if valid drive and locked, hard-code attributes
|
|
|
1222 |
rel = GetLocalDrive(drive).Caps(capsBuf);
|
|
|
1223 |
}
|
|
|
1224 |
else // this need to be made a bit nicer
|
|
|
1225 |
{
|
|
|
1226 |
CExtProxyDrive* pD = GetProxyDrive(drive);
|
|
|
1227 |
if(pD)
|
|
|
1228 |
rel = pD->Caps(capsBuf);
|
|
|
1229 |
else
|
|
|
1230 |
rel = KErrNotReady;
|
|
|
1231 |
}
|
|
|
1232 |
|
|
|
1233 |
if (rel != KErrNone)
|
|
|
1234 |
{
|
|
|
1235 |
ioInfo.iBlockSize = rel;
|
|
|
1236 |
}
|
|
|
1237 |
else
|
|
|
1238 |
{
|
|
|
1239 |
TLocalDriveCapsV6& caps = capsBuf();
|
|
|
1240 |
if (caps.iBlockSize)
|
|
|
1241 |
{
|
|
|
1242 |
ioInfo.iBlockSize = caps.iBlockSize;
|
|
|
1243 |
}
|
|
|
1244 |
// returns default size (512) when block is not supported by
|
|
|
1245 |
// underlying media
|
|
|
1246 |
else
|
|
|
1247 |
{
|
|
|
1248 |
ioInfo.iBlockSize = KDefaultVolumeBlockSize;
|
|
|
1249 |
}
|
|
|
1250 |
}
|
|
|
1251 |
}
|
|
|
1252 |
|
|
|
1253 |
// 2. gets cluster size via mounted file system; Also get Max. file size supported by the file system
|
|
|
1254 |
|
|
|
1255 |
ioInfo.iMaxSupportedFileSize = KMaxTUint64; //-- the value for "not supported case"
|
|
|
1256 |
|
|
|
1257 |
if (pDrive->IsMounted())
|
|
|
1258 |
{
|
|
|
1259 |
rel = pDrive->CurrentMount().FileSystemClusterSize();
|
|
|
1260 |
ioInfo.iClusterSize = rel; // return cluster size or an error code if error happened.
|
|
|
1261 |
|
|
|
1262 |
pDrive->CurrentMount().GetMaxSupportedFileSize(ioInfo.iMaxSupportedFileSize);
|
|
|
1263 |
|
|
|
1264 |
}
|
|
|
1265 |
else
|
|
|
1266 |
{
|
|
|
1267 |
ioInfo.iClusterSize = KErrNotReady;
|
|
|
1268 |
}
|
|
|
1269 |
|
|
|
1270 |
// 3. get rec buffer size from estart.txt file
|
|
|
1271 |
{
|
|
|
1272 |
_LIT8(KLitSectionNameDrive,"Drive%C");
|
|
|
1273 |
ioInfo.iRecReadBufSize = KErrNotSupported;
|
|
|
1274 |
ioInfo.iRecWriteBufSize = KErrNotSupported;
|
|
|
1275 |
|
|
|
1276 |
TBuf8<8> sectionName;
|
|
|
1277 |
TInt32 bufSize;
|
|
|
1278 |
sectionName.Format(KLitSectionNameDrive, 'A' + drive);
|
|
|
1279 |
// retrieve recommended buffer size information through F32 INI section
|
|
|
1280 |
if (F32Properties::GetInt(sectionName, _L8("RecReadBufSize"), bufSize))
|
|
|
1281 |
{
|
|
|
1282 |
ioInfo.iRecReadBufSize = bufSize;
|
|
|
1283 |
}
|
|
|
1284 |
if (F32Properties::GetInt(sectionName, _L8("RecWriteBufSize"), bufSize))
|
|
|
1285 |
{
|
|
|
1286 |
ioInfo.iRecWriteBufSize = bufSize;
|
|
|
1287 |
}
|
|
|
1288 |
|
|
|
1289 |
// packaging and returning results
|
|
|
1290 |
TPckgBuf<TVolumeIOParamInfo> pckgBuf(ioInfo);
|
|
|
1291 |
aRequest->WriteL(KMsgPtr2, pckgBuf);
|
|
|
1292 |
}
|
|
|
1293 |
|
|
|
1294 |
// always return KErrNone as error codes are packaged and returned via ioInfo members
|
|
|
1295 |
return KErrNone;
|
|
|
1296 |
} //case EIOParamInfo:
|
|
|
1297 |
|
|
|
1298 |
//-------------------------------------------------
|
|
|
1299 |
//-- check if the specified drive is synchronous or not
|
|
|
1300 |
case EIsDriveSync:
|
|
|
1301 |
{
|
|
|
1302 |
const TInt drive = aRequest->Message().Int0();
|
|
|
1303 |
const TBool bDrvSynch = FsThreadManager::IsDriveSync(drive, EFalse);
|
|
|
1304 |
TPckgBuf<TBool> buf(bDrvSynch);
|
|
|
1305 |
aRequest->WriteL(KMsgPtr2, buf);
|
|
|
1306 |
|
|
|
1307 |
return KErrNone;
|
|
|
1308 |
}
|
|
|
1309 |
|
|
|
1310 |
//-------------------------------------------------
|
|
|
1311 |
//-- query if the drive is finalised
|
|
|
1312 |
case EIsDriveFinalised:
|
|
|
1313 |
{
|
|
|
1314 |
TBool bFinalised;
|
|
|
1315 |
TInt nRes = pDrive->CurrentMount().IsMountFinalised(bFinalised);
|
|
|
1316 |
if(nRes != KErrNone)
|
|
|
1317 |
return nRes;
|
|
|
1318 |
|
|
|
1319 |
TPckgBuf<TBool> buf(bFinalised);
|
|
|
1320 |
aRequest->WriteL(KMsgPtr2, buf);
|
|
|
1321 |
|
|
|
1322 |
return KErrNone;
|
|
|
1323 |
}
|
|
132
|
1324 |
case EFSysExtensionsSupported:
|
|
|
1325 |
{
|
|
|
1326 |
TBool supported = pDrive->GetFSys()->IsExtensionSupported();
|
|
|
1327 |
TPckgBuf<TBool> data(supported);
|
|
|
1328 |
aRequest->WriteL(KMsgPtr2,data);
|
|
|
1329 |
return KErrNone;
|
|
|
1330 |
}
|
|
0
|
1331 |
default:
|
|
|
1332 |
{
|
|
|
1333 |
return KErrNotSupported;
|
|
|
1334 |
}
|
|
|
1335 |
}
|
|
|
1336 |
}
|
|
|
1337 |
|
|
|
1338 |
TInt TFsQueryVolumeInfoExt::Initialise(CFsRequest* aRequest)
|
|
|
1339 |
{
|
|
|
1340 |
TInt r = ValidateDriveDoSubst(aRequest->Message().Int0(),aRequest);
|
|
|
1341 |
return r;
|
|
|
1342 |
}
|
|
|
1343 |
|
|
|
1344 |
TInt CKernEventNotifier::FreeMemoryChangeCallback()
|
|
|
1345 |
{
|
|
|
1346 |
__PRINT(_L("CKernEventNotifier::FreeMemoryChangeCallback"));
|
|
|
1347 |
|
|
|
1348 |
TBool belowThreshold = (iChange & EChangesLowMemory)?(TBool)ETrue:(TBool)EFalse;
|
|
|
1349 |
CCacheManager* manager = CCacheManagerFactory::CacheManager();
|
|
|
1350 |
if (manager)
|
|
|
1351 |
{
|
|
|
1352 |
manager->FreeMemoryChanged(belowThreshold);
|
|
|
1353 |
|
|
|
1354 |
// start flushing all dirty data
|
|
|
1355 |
if (belowThreshold)
|
|
|
1356 |
{
|
|
|
1357 |
Files->Lock();
|
|
|
1358 |
TInt count=Files->Count();
|
|
|
1359 |
while(count--)
|
|
|
1360 |
{
|
|
|
1361 |
CFileCB* file = (CFileCB*)(*Files)[count];
|
|
|
1362 |
if (file->FileCache())
|
|
|
1363 |
// Cannot report errors here
|
|
|
1364 |
// coverity [unchecked_value]
|
|
|
1365 |
(void)file->FileCache()->FlushDirty();
|
|
|
1366 |
}
|
|
|
1367 |
Files->Unlock();
|
|
|
1368 |
}
|
|
|
1369 |
}
|
|
|
1370 |
|
|
|
1371 |
#ifdef SYMBIAN_ENABLE_FAT_DIRECTORY_OPT
|
|
|
1372 |
CCacheMemoryManager* cacheMemManager = CCacheMemoryManagerFactory::CacheMemoryManager();
|
|
|
1373 |
if (cacheMemManager)
|
|
|
1374 |
cacheMemManager->FreeMemoryChanged(belowThreshold);
|
|
|
1375 |
#endif //#ifdef SYMBIAN_ENABLE_FAT_DIRECTORY_OPT
|
|
|
1376 |
|
|
|
1377 |
return KErrNone;
|
|
|
1378 |
}
|
|
|
1379 |
|