|
1 /* |
|
2 * Copyright (c) 2007 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 "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: WMDRM Server implementation |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 #include <f32file.h> |
|
20 #include <systemwarninglevels.hrh> |
|
21 #include "wmdrmfileserversession.h" |
|
22 #include "wmdrmfileserver.h" |
|
23 |
|
24 #define _LOGGING_FILE L"wmdrmfileserver.txt" |
|
25 |
|
26 // Due to TCB capability logging can not be used |
|
27 // #include "flogger.h" |
|
28 // #include "logfn.h" |
|
29 |
|
30 |
|
31 // rights server uid |
|
32 const TUint32 KRightsServer = 0x101F51F2; |
|
33 _LIT( KSecureStore, "securestore" ); |
|
34 _LIT( KLicenseStore, "licstore" ); |
|
35 _LIT( KDefaultNamespace, "hds"); |
|
36 |
|
37 _LIT( KStorePathTemplate, "%c:\\sys\\private\\2000B180\\%S\\%S\\"); |
|
38 |
|
39 // ======== LOCAL FUNCTIONS ======== |
|
40 |
|
41 // Implmentation from securitycheckutil.cpp with some reductions |
|
42 |
|
43 LOCAL_C TBool CheckFileName(const TFileName& aFileName, TChar aSystemDriveChar) |
|
44 { |
|
45 |
|
46 if (aFileName.Length() > KMaxFileName) |
|
47 { |
|
48 return EFalse; |
|
49 } |
|
50 |
|
51 // Check for full drive and path |
|
52 TChar drive(aFileName[0]); |
|
53 |
|
54 _LIT(KDriveSeparator, ":\\"); |
|
55 if (!drive.IsAlpha() || aFileName.Find(KDriveSeparator) != 1) |
|
56 { |
|
57 return EFalse; |
|
58 } |
|
59 |
|
60 // Check for double slashes |
|
61 _LIT(KDoubleSlash, "\\\\"); |
|
62 if (aFileName.Find(KDoubleSlash) != KErrNotFound) |
|
63 { |
|
64 return EFalse; |
|
65 } |
|
66 |
|
67 // Check for .. in the path |
|
68 _LIT(KDoubleDotPath, "..\\"); |
|
69 if (aFileName.Find(KDoubleDotPath) != KErrNotFound) |
|
70 { |
|
71 return EFalse; |
|
72 } |
|
73 |
|
74 // Check for references to writable SwiCertstore |
|
75 _LIT(KWritableSwiCertStore, ":\\Resource\\SwiCertstore"); |
|
76 TBuf<32> writableSwiCertStorePath; |
|
77 writableSwiCertStorePath.Append(aSystemDriveChar); |
|
78 writableSwiCertStorePath.Append(KWritableSwiCertStore); |
|
79 |
|
80 if (aFileName.FindF(writableSwiCertStorePath) != KErrNotFound) |
|
81 { |
|
82 return EFalse; |
|
83 } |
|
84 |
|
85 return ETrue; |
|
86 } |
|
87 |
|
88 |
|
89 |
|
90 LOCAL_C TBool IsSubstedDriveL(RFs& aFs, const TFileName& aFileName) |
|
91 { |
|
92 TChar drvCh = aFileName[0]; |
|
93 TInt drvNum; |
|
94 User::LeaveIfError(RFs::CharToDrive(drvCh, drvNum)); |
|
95 TDriveInfo drvInfo; |
|
96 User::LeaveIfError(aFs.Drive(drvInfo, drvNum)); |
|
97 //if the drive is subst'd return true |
|
98 if(drvInfo.iDriveAtt & KDriveAttSubsted) |
|
99 { |
|
100 return ETrue; |
|
101 } |
|
102 return EFalse; |
|
103 } |
|
104 |
|
105 |
|
106 |
|
107 |
|
108 // --------------------------------------------------------------------------- |
|
109 // Create a safe filename which can be used under the WMDRM file server |
|
110 // root by filtering all illegal characters |
|
111 // --------------------------------------------------------------------------- |
|
112 // |
|
113 LOCAL_C void CreateSafeFileNameL( |
|
114 TFileName& aTarget, |
|
115 const TBuf<KFileNameSize>& aSource, |
|
116 RFs &aFs ) |
|
117 { |
|
118 TInt i; |
|
119 TChar c; |
|
120 TBool suffix = ETrue; |
|
121 |
|
122 TInt driveNumber( RFs::GetSystemDrive() ); |
|
123 TChar driveLetter; |
|
124 User::LeaveIfError( RFs::DriveToChar( driveNumber, driveLetter ) ); |
|
125 |
|
126 TFileName storeRootFile; |
|
127 storeRootFile.Format( KStoreRoot, (TUint)driveLetter ); |
|
128 |
|
129 if ( aSource.Length() + storeRootFile.Length() + 1 > aTarget.MaxLength() - aTarget.Length() ) |
|
130 { |
|
131 User::Leave( KErrArgument ); |
|
132 } |
|
133 |
|
134 aTarget.Copy( storeRootFile ); |
|
135 aTarget.Append( '\\' ); |
|
136 for ( i = 0 ; i < aSource.Length(); i++ ) |
|
137 { |
|
138 c = aSource[i]; |
|
139 |
|
140 // Change all non-alphanumeric characters to underscores, |
|
141 // except for the colon separating the file suffix |
|
142 if ( !c.IsAlphaDigit() && !suffix ) |
|
143 { |
|
144 c = '_'; |
|
145 } |
|
146 |
|
147 // Once the suffix colon has been processed, replace all non-alphanumeric characters |
|
148 if ( suffix && c == '.' ) |
|
149 { |
|
150 suffix = EFalse; |
|
151 } |
|
152 aTarget.Append( c ); |
|
153 } |
|
154 |
|
155 if( IsSubstedDriveL( aFs, aTarget ) || !CheckFileName( aTarget, driveLetter ) ) |
|
156 { |
|
157 User::Leave(KErrArgument); |
|
158 } |
|
159 } |
|
160 |
|
161 // --------------------------------------------------------------------------- |
|
162 // Extract the path components from a full filename |
|
163 // --------------------------------------------------------------------------- |
|
164 // |
|
165 LOCAL_C void GetPath( const TDesC& aFilename, TPtrC& aPath ) |
|
166 { |
|
167 TInt i = aFilename.Length() - 1; |
|
168 while ( i >= 0 && aFilename[i] != '\\' ) |
|
169 { |
|
170 i--; |
|
171 } |
|
172 if ( aFilename[i] == '\\' ) |
|
173 { |
|
174 i++; |
|
175 } |
|
176 return aPath.Set( aFilename.Left( i ) ); |
|
177 } |
|
178 |
|
179 // --------------------------------------------------------------------------- |
|
180 // Check if system drive has <= KDRIVECCRITICALTHRESHOLD free space and in |
|
181 // that case leave with KErrDiskFull |
|
182 // --------------------------------------------------------------------------- |
|
183 // |
|
184 LOCAL_C void CheckFreeSpaceL( RFs &aFs, TInt aBytesToWrite ) |
|
185 { |
|
186 TVolumeInfo info; |
|
187 User::LeaveIfError( aFs.Volume( info, aFs.GetSystemDrive() ) ); |
|
188 if ( info.iFree - aBytesToWrite <= KDRIVECCRITICALTHRESHOLD ) |
|
189 { |
|
190 User::Leave( KErrDiskFull ); |
|
191 } |
|
192 } |
|
193 |
|
194 // ======== MEMBER FUNCTIONS ======== |
|
195 |
|
196 CWmDrmFileServerSession::CWmDrmFileServerSession() |
|
197 { |
|
198 //LOGFN( "CWmDrmFileServerSession::CWmDrmFileServerSession" ); |
|
199 } |
|
200 |
|
201 CWmDrmFileServerSession::~CWmDrmFileServerSession() |
|
202 { |
|
203 //LOGFN( "CWmDrmFileServerSession::~CWmDrmFileServerSession" ); |
|
204 iFile.Close(); |
|
205 } |
|
206 |
|
207 TInt CWmDrmFileServerSession::OpenL( const RMessage2& aMessage ) |
|
208 { |
|
209 TInt r = KErrNone; |
|
210 TFileName path; |
|
211 TBuf<KFileNameSize> fileName; |
|
212 |
|
213 //LOGFNR( "CWmDrmFileServerSession::OpenL", r ); |
|
214 __UHEAP_MARK; |
|
215 if ( aMessage.GetDesLength( 0 ) > KFileNameSize ) |
|
216 { |
|
217 User::Leave( KErrArgument ); |
|
218 } |
|
219 iFile.Close(); |
|
220 aMessage.ReadL( 0, fileName ); |
|
221 CreateSafeFileNameL( path, fileName, Server().Fs() ); |
|
222 //LOG( path ); |
|
223 r = iFile.Open( Server().Fs(), path, EFileRead | EFileWrite ); |
|
224 __UHEAP_MARKEND; |
|
225 return r; |
|
226 } |
|
227 |
|
228 TInt CWmDrmFileServerSession::CreateL( const RMessage2& aMessage ) |
|
229 { |
|
230 TInt r = KErrNone; |
|
231 TFileName path; |
|
232 TBuf<KFileNameSize> fileName; |
|
233 TPtrC folders( NULL, 0 ); |
|
234 |
|
235 //LOGFNR( "CWmDrmFileServerSession::CreateL", r ); |
|
236 __UHEAP_MARK; |
|
237 if ( aMessage.GetDesLength( 0 ) > KFileNameSize ) |
|
238 { |
|
239 User::Leave( KErrArgument ); |
|
240 } |
|
241 iFile.Close(); |
|
242 aMessage.ReadL( 0, fileName ); |
|
243 //LOG( fileName ); |
|
244 CreateSafeFileNameL( path, fileName, Server().Fs() ); |
|
245 GetPath( path, folders ); |
|
246 |
|
247 CheckFreeSpaceL( Server().Fs(), 0 ); |
|
248 |
|
249 Server().Fs().MkDirAll( folders ); |
|
250 //LOG( path ); |
|
251 r = iFile.Replace( Server().Fs(), path, EFileRead | EFileWrite ); |
|
252 __UHEAP_MARKEND; |
|
253 return r; |
|
254 } |
|
255 |
|
256 TInt CWmDrmFileServerSession::ReadL( const RMessage2& aMessage ) |
|
257 { |
|
258 TInt r = KErrNone; |
|
259 RBuf8 buf; |
|
260 TInt amountRead = 0; |
|
261 TInt pos = 0; |
|
262 |
|
263 //LOGFNR( "CWmDrmFileServerSession::ReadL", r ); |
|
264 __UHEAP_MARK; |
|
265 if ( iFile.SubSessionHandle() == KNullHandle ) |
|
266 { |
|
267 User::Leave( KErrNotReady ); |
|
268 } |
|
269 |
|
270 buf.CreateL( aMessage.GetDesMaxLengthL( 0 ) ); |
|
271 CleanupClosePushL( buf ); |
|
272 iFile.Seek( ESeekStart, pos ); |
|
273 r = iFile.Read( buf ); |
|
274 if ( r == KErrNone ) |
|
275 { |
|
276 aMessage.WriteL( 0, buf ); |
|
277 amountRead = buf.Size(); |
|
278 } |
|
279 aMessage.WriteL( 1, TPckg<TInt>( amountRead ) ); |
|
280 //LOG2( "Read %d bytes", amountRead ); |
|
281 CleanupStack::PopAndDestroy(); // buf |
|
282 __UHEAP_MARKEND; |
|
283 return r; |
|
284 } |
|
285 |
|
286 TInt CWmDrmFileServerSession::WriteL( const RMessage2& aMessage ) |
|
287 { |
|
288 TInt r = KErrNone; |
|
289 RBuf8 buf; |
|
290 TInt pos = 0; |
|
291 |
|
292 //LOGFNR( "CWmDrmFileServerSession::WriteL", r ); |
|
293 __UHEAP_MARK; |
|
294 if ( iFile.SubSessionHandle() == KNullHandle ) |
|
295 { |
|
296 User::Leave( KErrNotReady ); |
|
297 } |
|
298 |
|
299 CheckFreeSpaceL( Server().Fs(), aMessage.GetDesLengthL( 0 ) ); |
|
300 |
|
301 buf.CreateL( aMessage.GetDesLengthL( 0 ) ); |
|
302 CleanupClosePushL( buf ); |
|
303 aMessage.ReadL( 0, buf ); |
|
304 iFile.Seek( ESeekStart, pos ); |
|
305 iFile.SetSize( 0 ); |
|
306 r = iFile.Write( buf ); |
|
307 CleanupStack::PopAndDestroy(); // buf |
|
308 __UHEAP_MARKEND; |
|
309 return r; |
|
310 } |
|
311 |
|
312 TInt CWmDrmFileServerSession::SizeL( const RMessage2& aMessage ) |
|
313 { |
|
314 TInt r = KErrNone; |
|
315 TInt size; |
|
316 |
|
317 //LOGFNR( "CWmDrmFileServerSession::SizeL", r ); |
|
318 __UHEAP_MARK; |
|
319 if ( iFile.SubSessionHandle() == KNullHandle ) |
|
320 { |
|
321 User::Leave( KErrNotReady ); |
|
322 } |
|
323 r = iFile.Size( size ); |
|
324 if ( r == KErrNone ) |
|
325 { |
|
326 aMessage.WriteL( 0, TPckg<TInt>( size ) ); |
|
327 } |
|
328 __UHEAP_MARKEND; |
|
329 return r; |
|
330 } |
|
331 |
|
332 TInt CWmDrmFileServerSession::IsOpenL( const RMessage2& /*aMessage*/ ) |
|
333 { |
|
334 TInt r = KErrNone; |
|
335 |
|
336 //LOGFNR( "CWmDrmFileServerSession::IsOpenL", r ); |
|
337 if ( iFile.SubSessionHandle() == KNullHandle ) |
|
338 { |
|
339 r = KErrNotReady; |
|
340 } |
|
341 return r; |
|
342 } |
|
343 |
|
344 TInt CWmDrmFileServerSession::CloseFileL( const RMessage2& /*aMessage*/ ) |
|
345 { |
|
346 TInt r = KErrNone; |
|
347 |
|
348 //LOGFNR( "CWmDrmFileServerSession::CloseFileL", r ); |
|
349 iFile.Close(); |
|
350 return r; |
|
351 } |
|
352 |
|
353 TInt CWmDrmFileServerSession::DeleteL( const RMessage2& aMessage ) |
|
354 { |
|
355 TInt r = KErrNone; |
|
356 TFileName path; |
|
357 TBuf<KFileNameSize> fileName; |
|
358 |
|
359 //LOGFNR( "CWmDrmFileServerSession::DeleteL", r ); |
|
360 __UHEAP_MARK; |
|
361 if ( aMessage.GetDesLength( 0 ) > KFileNameSize ) |
|
362 { |
|
363 User::Leave( KErrArgument ); |
|
364 } |
|
365 aMessage.ReadL( 0, fileName ); |
|
366 CreateSafeFileNameL( path, fileName, Server().Fs() ); |
|
367 r = Server().Fs().Delete( path ); |
|
368 //LOG( path ); |
|
369 __UHEAP_MARKEND; |
|
370 return r; |
|
371 } |
|
372 |
|
373 TInt CWmDrmFileServerSession::MkDirAllL( const RMessage2& aMessage ) |
|
374 { |
|
375 TInt r = KErrNone; |
|
376 TFileName path; |
|
377 TBuf<KFileNameSize> fileName; |
|
378 TUint att; |
|
379 |
|
380 //LOGFNR( "CWmDrmFileServerSession::MkDirAllL", r ); |
|
381 __UHEAP_MARK; |
|
382 if ( aMessage.GetDesLength( 0 ) > KFileNameSize ) |
|
383 { |
|
384 User::Leave( KErrArgument ); |
|
385 } |
|
386 aMessage.ReadL( 0, fileName ); |
|
387 CreateSafeFileNameL( path, fileName, Server().Fs() ); |
|
388 //LOG( path ); |
|
389 if ( !aMessage.Int1() && ( r = Server().Fs().Att( path, att ) ) != KErrNone ) |
|
390 { |
|
391 User::Leave( r ); |
|
392 } |
|
393 |
|
394 CheckFreeSpaceL( Server().Fs(), 0 ); |
|
395 |
|
396 r = Server().Fs().MkDirAll( path ); |
|
397 __UHEAP_MARKEND; |
|
398 return r; |
|
399 } |
|
400 |
|
401 TInt CWmDrmFileServerSession::RmDirAllL( const RMessage2& aMessage ) |
|
402 { |
|
403 TInt r = KErrNone; |
|
404 TFileName path; |
|
405 TBuf<KFileNameSize> fileName; |
|
406 CFileMan* fileMan; |
|
407 |
|
408 //LOGFNR( "CWmDrmFileServerSession::RmDirAllL", r ); |
|
409 __UHEAP_MARK; |
|
410 if ( aMessage.GetDesLength( 0 ) > KFileNameSize ) |
|
411 { |
|
412 User::Leave( KErrArgument ); |
|
413 } |
|
414 fileMan = CFileMan::NewL( Server().Fs() ); |
|
415 CleanupStack::PushL( fileMan ); |
|
416 aMessage.ReadL( 0, fileName ); |
|
417 CreateSafeFileNameL( path, fileName, Server().Fs() ); |
|
418 r = fileMan->RmDir( path ); |
|
419 //LOG( path ); |
|
420 CleanupStack::PopAndDestroy(); // fileMan |
|
421 __UHEAP_MARKEND; |
|
422 return r; |
|
423 } |
|
424 |
|
425 TInt CWmDrmFileServerSession::RmDirL( const RMessage2& aMessage ) |
|
426 { |
|
427 TInt r = KErrNone; |
|
428 TFileName path; |
|
429 TBuf<KFileNameSize> fileName; |
|
430 |
|
431 //LOGFNR( "CWmDrmFileServerSession::RmDirL", r ); |
|
432 __UHEAP_MARK; |
|
433 if ( aMessage.GetDesLength( 0 ) > KFileNameSize ) |
|
434 { |
|
435 User::Leave( KErrArgument ); |
|
436 } |
|
437 aMessage.ReadL( 0, fileName ); |
|
438 CreateSafeFileNameL( path, fileName, Server().Fs() ); |
|
439 r = Server().Fs().RmDir( path ); |
|
440 //LOG( path ); |
|
441 __UHEAP_MARKEND; |
|
442 return r; |
|
443 } |
|
444 |
|
445 |
|
446 TInt CWmDrmFileServerSession::UpdateSecureTimeL( const RMessage2& aMessage ) |
|
447 { |
|
448 TInt r = KErrNone; |
|
449 TTime homeTime; |
|
450 TTime utcTime; |
|
451 RThread client; |
|
452 |
|
453 TPckg<TTime> package( homeTime ); |
|
454 TPckg<TTime> package2( utcTime ); |
|
455 |
|
456 // Get the client: |
|
457 aMessage.ClientL( client ); |
|
458 CleanupClosePushL( client ); |
|
459 |
|
460 // Check client, if client is not the rights server, access denied: |
|
461 _LIT_SECURITY_POLICY_S0(swSidCheck2, KRightsServer); |
|
462 |
|
463 if( !swSidCheck2().CheckPolicy(client) ) |
|
464 { |
|
465 User::Leave( KErrAccessDenied ); |
|
466 } |
|
467 |
|
468 CleanupStack::PopAndDestroy( &client ); |
|
469 |
|
470 aMessage.ReadL( 0, package ); |
|
471 aMessage.ReadL( 1, package2 ); |
|
472 |
|
473 // Set the secure time: |
|
474 User::LeaveIfError( User::SetUTCTimeSecure( utcTime ) ); |
|
475 //User::LeaveIfError( User::SetHomeTimeSecure( homeTime ) ); |
|
476 |
|
477 return r; |
|
478 } |
|
479 |
|
480 TInt CWmDrmFileServerSession::DeleteRightsL( const RMessage2& /*aMessage*/ ) |
|
481 { |
|
482 TInt r = KErrNone; |
|
483 TInt finalErr = KErrNone; |
|
484 TFileName storeRootFile; |
|
485 CFileMan* fileMan = NULL; |
|
486 |
|
487 //LOGFNR( "CWmDrmFileServerSession::DeleteRightsL", r ); |
|
488 __UHEAP_MARK; |
|
489 fileMan = CFileMan::NewL( Server().Fs() ); |
|
490 CleanupStack::PushL( fileMan ); |
|
491 // Remove the stores: |
|
492 TInt driveNumber( RFs::GetSystemDrive() ); |
|
493 TChar driveLetter; |
|
494 User::LeaveIfError( RFs::DriveToChar( driveNumber, driveLetter ) ); |
|
495 |
|
496 storeRootFile.Format( KStorePathTemplate, (TUint)driveLetter, &KDefaultNamespace, &KLicenseStore ); |
|
497 //r = Server().Fs().RmDir( storeRootFile ); |
|
498 r = fileMan->RmDir( storeRootFile ); |
|
499 if( r < KErrNone ) |
|
500 { |
|
501 finalErr = r; |
|
502 } |
|
503 |
|
504 storeRootFile.Format( KStorePathTemplate, (TUint)driveLetter, &KDefaultNamespace, &KSecureStore ); |
|
505 //r = Server().Fs().RmDir( storeRootFile ); |
|
506 r = fileMan->RmDir( storeRootFile ); |
|
507 if( !finalErr && r < KErrNone ) |
|
508 { |
|
509 finalErr = r; |
|
510 } |
|
511 |
|
512 CleanupStack::PopAndDestroy( fileMan ); |
|
513 __UHEAP_MARKEND; |
|
514 return finalErr; |
|
515 } |
|
516 |
|
517 // --------------------------------------------------------------------------- |
|
518 // Main service function. All services require DRM capability! |
|
519 // --------------------------------------------------------------------------- |
|
520 // |
|
521 void CWmDrmFileServerSession::ServiceL( const RMessage2& aMessage ) |
|
522 { |
|
523 TInt r = KErrNone; |
|
524 TInt trap = KErrNone; |
|
525 _LIT_SECURITY_POLICY_C1(drmCheck, ECapabilityDRM); |
|
526 RThread client; |
|
527 |
|
528 //LOGFNR( "CWmDrmFileServerSession::ServiceL", r ); |
|
529 #ifdef _LOGGING |
|
530 TInt c; |
|
531 TInt s; |
|
532 c = User::AllocSize(s); |
|
533 //LOG3( "Memory: %d cells, %d bytes allocated", c, s ); |
|
534 #endif |
|
535 |
|
536 aMessage.ClientL( client ); |
|
537 if ( !drmCheck().CheckPolicy( client ) ) |
|
538 { |
|
539 r = KErrAccessDenied; |
|
540 } |
|
541 else |
|
542 { |
|
543 switch ( aMessage.Function() ) |
|
544 { |
|
545 case EFsOpen: |
|
546 TRAP( trap, r = OpenL( aMessage ) ); |
|
547 break; |
|
548 case EFsCreate: |
|
549 TRAP( trap, r = CreateL( aMessage ) ); |
|
550 break; |
|
551 case EFsRead: |
|
552 TRAP( trap, r = ReadL( aMessage ) ); |
|
553 break; |
|
554 case EFsWrite: |
|
555 TRAP( trap, r = WriteL( aMessage ) ); |
|
556 break; |
|
557 case EFsSize: |
|
558 TRAP( trap, r = SizeL( aMessage ) ); |
|
559 break; |
|
560 case EFsDelete: |
|
561 TRAP( trap, r = DeleteL( aMessage ) ); |
|
562 break; |
|
563 case EFsIsOpen: |
|
564 TRAP( trap, r = IsOpenL( aMessage ) ); |
|
565 break; |
|
566 case EFsCloseFile: |
|
567 TRAP( trap, r = CloseFileL( aMessage ) ); |
|
568 break; |
|
569 case EFsMkDirAll: |
|
570 TRAP( trap, r = MkDirAllL( aMessage ) ); |
|
571 break; |
|
572 case EFsRmDirAll: |
|
573 TRAP( trap, r = RmDirAllL( aMessage ) ); |
|
574 break; |
|
575 case EFsRmDir: |
|
576 TRAP( trap, r = RmDirL( aMessage ) ); |
|
577 break; |
|
578 case EFsUpdateSecureTime: |
|
579 TRAP( trap, r = UpdateSecureTimeL( aMessage ) ); |
|
580 break; |
|
581 case EFsDeleteRights: |
|
582 TRAP( trap, r = DeleteRightsL( aMessage ) ); |
|
583 break; |
|
584 default: |
|
585 PanicClient( aMessage, EPanicIllegalFunction ); |
|
586 break; |
|
587 } |
|
588 if ( trap != KErrNone ) |
|
589 { |
|
590 r = trap; |
|
591 } |
|
592 } |
|
593 client.Close(); |
|
594 if ( !aMessage.IsNull() ) |
|
595 { |
|
596 aMessage.Complete( r ); |
|
597 } |
|
598 } |
|
599 |
|
600 void CWmDrmFileServerSession::ServiceError( const RMessage2& aMessage, TInt aError ) |
|
601 { |
|
602 //LOGFN( "CWmDrmFileServerSession::ServiceError" ); |
|
603 //LOG2( "** Error: %d", aError ); |
|
604 if ( aError == KErrBadDescriptor ) |
|
605 { |
|
606 PanicClient( aMessage, EPanicBadDescriptor ); |
|
607 } |
|
608 if ( !aMessage.IsNull() ) |
|
609 { |
|
610 CSession2::ServiceError( aMessage, aError ); |
|
611 } |
|
612 } |
|
613 |
|
614 CWmDrmFileServer& CWmDrmFileServerSession::Server() |
|
615 { |
|
616 return *static_cast<CWmDrmFileServer*>( const_cast<CServer2*>( CSession2::Server() ) ); |
|
617 } |