|
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 "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 // USER INCLUDE |
|
18 #include "blacklistserver.h" |
|
19 #include "blacklistcommon.h" |
|
20 #include "blacklistsession.h" |
|
21 #include "blacklistitem.h" |
|
22 #include "harvesterlog.h" |
|
23 #include "mdssqliteconnection.h" |
|
24 #include "mdcserializationbuffer.h" |
|
25 |
|
26 #include <PathInfo.h> |
|
27 |
|
28 // Security policy |
|
29 const TUint KServerPolicyRangeCount = 6; |
|
30 // Database file without the drive letter |
|
31 _LIT( KBlacklistDatabaseFile, ":[2001B2EB]blacklistdb.sq" ); |
|
32 |
|
33 const TInt KServerPolicyRanges[KServerPolicyRangeCount] = |
|
34 { |
|
35 EBlacklistAdd, |
|
36 EBlacklistRemove, |
|
37 EBlacklistRemoveFromDB, |
|
38 EGetBlacklistData, |
|
39 EBlacklistCloseDB, |
|
40 EMaxService |
|
41 }; |
|
42 |
|
43 const TUint8 KServerPolicyElementsIndex[KServerPolicyRangeCount] = |
|
44 { |
|
45 CPolicyServer::ECustomCheck, // EBlacklistAdd |
|
46 CPolicyServer::ECustomCheck, // EBlacklistRemove |
|
47 CPolicyServer::ECustomCheck, // EBlacklistRemoveFromDB |
|
48 CPolicyServer::ECustomCheck, // EGetBlacklistData |
|
49 CPolicyServer::ECustomCheck, // EBlacklistCloseDB |
|
50 CPolicyServer::ECustomCheck // EMaxService |
|
51 }; |
|
52 |
|
53 const CPolicyServer::TPolicy KServerPolicy = |
|
54 { |
|
55 CPolicyServer::EAlwaysPass, // specifies all connect attempts should pass |
|
56 KServerPolicyRangeCount, |
|
57 KServerPolicyRanges, |
|
58 KServerPolicyElementsIndex, |
|
59 NULL |
|
60 }; |
|
61 |
|
62 // --------------------------------------------------------------------------- |
|
63 // CBlacklistServer::CustomSecurityCheckL() |
|
64 // --------------------------------------------------------------------------- |
|
65 // |
|
66 CPolicyServer::TCustomResult CBlacklistServer::CustomSecurityCheckL( |
|
67 const RMessage2& aMsg, TInt& /*aAction*/, TSecurityInfo& /*aMissing*/ ) |
|
68 { |
|
69 WRITELOG( "CBlacklistServer::CustomSecurityCheckL - begin" ); |
|
70 |
|
71 CPolicyServer::TCustomResult securityCheckResult = EFail; |
|
72 |
|
73 switch ( aMsg.Function() ) |
|
74 { |
|
75 case EBlacklistAdd: |
|
76 case EBlacklistRemove: |
|
77 case EBlacklistRemoveFromDB: |
|
78 case EGetBlacklistData: |
|
79 case EBlacklistCloseDB: |
|
80 case EMaxService: |
|
81 { |
|
82 if( aMsg.HasCapability( ECapabilityWriteDeviceData ) ) |
|
83 { |
|
84 securityCheckResult = EPass; |
|
85 } |
|
86 } |
|
87 break; |
|
88 default: |
|
89 { |
|
90 securityCheckResult = EFail; |
|
91 } |
|
92 } |
|
93 |
|
94 WRITELOG( "CBlacklistServer::CustomSecurityCheckL - end" ); |
|
95 |
|
96 return securityCheckResult; |
|
97 } |
|
98 |
|
99 |
|
100 // --------------------------------------------------------------------------- |
|
101 // CBlacklistServer::CustomFailureActionL() |
|
102 // --------------------------------------------------------------------------- |
|
103 // |
|
104 CPolicyServer::TCustomResult CBlacklistServer::CustomFailureActionL( |
|
105 const RMessage2& /*aMsg*/, TInt /*aAction*/, const TSecurityInfo& /*aMissing*/ ) |
|
106 { |
|
107 WRITELOG( "CBlacklistServer::CustomFailureActionL" ); |
|
108 |
|
109 // Not used |
|
110 return EFail; |
|
111 } |
|
112 |
|
113 // --------------------------------------------------------------------------- |
|
114 // CBlacklistServer::NewL() |
|
115 // --------------------------------------------------------------------------- |
|
116 // |
|
117 CBlacklistServer* CBlacklistServer::NewL() |
|
118 { |
|
119 WRITELOG( "CBlacklistServer::NewL - begin" ); |
|
120 |
|
121 CBlacklistServer* self = NewLC(); |
|
122 CleanupStack::Pop( self ); |
|
123 |
|
124 WRITELOG( "CBlacklistServer::NewL - end" ); |
|
125 return self; |
|
126 } |
|
127 |
|
128 // --------------------------------------------------------------------------- |
|
129 // CBlacklistServer::NewLC() |
|
130 // --------------------------------------------------------------------------- |
|
131 // |
|
132 CBlacklistServer* CBlacklistServer::NewLC() |
|
133 { |
|
134 WRITELOG( "CBlacklistServer::NewLC - begin" ); |
|
135 |
|
136 CBlacklistServer* self = new( ELeave ) CBlacklistServer(); |
|
137 CleanupStack::PushL( self ); |
|
138 self->ConstructL(); |
|
139 |
|
140 WRITELOG( "CBlacklistServer::NewLC - end" ); |
|
141 return self; |
|
142 } |
|
143 |
|
144 // --------------------------------------------------------------------------- |
|
145 // CBlacklistServer::CBlacklistServer() |
|
146 // --------------------------------------------------------------------------- |
|
147 // |
|
148 CBlacklistServer::CBlacklistServer() : |
|
149 CPolicyServer( CActive::EPriorityStandard, KServerPolicy, ESharableSessions ) |
|
150 { |
|
151 } |
|
152 |
|
153 void CBlacklistServer::ConstructL() |
|
154 { |
|
155 WRITELOG( "CBlacklistServer::ConstructL - begin" ); |
|
156 |
|
157 TInt error = Start( KBlacklistServerName ); |
|
158 |
|
159 if ( error != KErrNone ) |
|
160 { |
|
161 __ASSERT_DEBUG( EFalse, User::Panic( KBlacklistServerName, error )); |
|
162 } |
|
163 |
|
164 iSqLiteConnection = CMdSSqLiteConnection::NewL(); |
|
165 |
|
166 WRITELOG( "CBlacklistServer::ConstructL - end" ); |
|
167 } |
|
168 |
|
169 // --------------------------------------------------------------------------- |
|
170 // CBlacklistServer::~CBlacklistServer() |
|
171 // --------------------------------------------------------------------------- |
|
172 // |
|
173 CBlacklistServer::~CBlacklistServer() |
|
174 { |
|
175 WRITELOG( "CBlacklistServer::~CBlacklistServer - begin" ); |
|
176 |
|
177 if ( iDatabaseOpen ) |
|
178 { |
|
179 if( iSqLiteConnection ) |
|
180 { |
|
181 iSqLiteConnection->CloseDb(); |
|
182 } |
|
183 } |
|
184 |
|
185 iBlacklistMemoryTable.ResetAndDestroy(); |
|
186 iBlacklistMemoryTable.Close(); |
|
187 |
|
188 |
|
189 const TInt KRowCountRemovedItems = iBufferedRemoveItems.Count(); |
|
190 |
|
191 for( TInt i = 0; i < KRowCountRemovedItems; i++ ) |
|
192 { |
|
193 iBufferedRemoveItems[i]->Close(); |
|
194 } |
|
195 |
|
196 iBufferedRemoveItems.ResetAndDestroy(); |
|
197 iBufferedRemoveItems.Close(); |
|
198 |
|
199 const TInt KRowCountAddedItems = iBufferedAddedItems.Count(); |
|
200 |
|
201 for( TInt i = 0; i < KRowCountAddedItems; i++ ) |
|
202 { |
|
203 iBufferedAddedItems[i]->Close(); |
|
204 } |
|
205 |
|
206 iBufferedAddedItems.ResetAndDestroy(); |
|
207 iBufferedAddedItems.Close(); |
|
208 |
|
209 iBlacklistServerChunk.Close(); |
|
210 |
|
211 delete iSqLiteConnection; |
|
212 |
|
213 WRITELOG( "CBlacklistServer::~CBlacklistServer - end" ); |
|
214 } |
|
215 |
|
216 // --------------------------------------------------------------------------- |
|
217 // Closes database connection. |
|
218 // --------------------------------------------------------------------------- |
|
219 // |
|
220 void CBlacklistServer::CloseDB() |
|
221 { |
|
222 WRITELOG( "CBlacklistServer::CloseDB - begin" ); |
|
223 |
|
224 if ( iDatabaseOpen ) |
|
225 { |
|
226 iSqLiteConnection->CloseDb(); |
|
227 iDatabaseOpen = EFalse; |
|
228 } |
|
229 |
|
230 WRITELOG( "CBlacklistServer::CloseDB - end" ); |
|
231 } |
|
232 |
|
233 // --------------------------------------------------------------------------- |
|
234 // CBlacklistServer::ExeMainL() |
|
235 // --------------------------------------------------------------------------- |
|
236 // |
|
237 void CBlacklistServer::ExeMainL() |
|
238 { |
|
239 WRITELOG( "CBlacklistServer::ExeMainL - begin" ); |
|
240 |
|
241 // Install active scheduler |
|
242 CActiveScheduler* scheduler = new( ELeave ) CActiveScheduler; |
|
243 CleanupStack::PushL( scheduler ); |
|
244 CActiveScheduler::Install( scheduler ); |
|
245 |
|
246 CBlacklistServer::NewLC(); |
|
247 |
|
248 User::LeaveIfError( User::RenameThread( KBlacklistServerName ) ); |
|
249 RProcess::Rendezvous( KErrNone ); |
|
250 |
|
251 CActiveScheduler::Start(); |
|
252 |
|
253 CleanupStack::PopAndDestroy( 2, scheduler ); |
|
254 |
|
255 WRITELOG( "CBlacklistServer::ExeMainL - end" ); |
|
256 } |
|
257 |
|
258 // --------------------------------------------------------------------------- |
|
259 // TInt E32Main() |
|
260 // --------------------------------------------------------------------------- |
|
261 // |
|
262 TInt E32Main() |
|
263 { |
|
264 WRITELOG( "CBlacklistServer::E32Main - begin" ); |
|
265 |
|
266 __UHEAP_MARK; |
|
267 |
|
268 CTrapCleanup* cleanup = CTrapCleanup::New(); |
|
269 |
|
270 TRAPD( error, CBlacklistServer::ExeMainL() ); |
|
271 __ASSERT_ALWAYS( !error, User::Panic( KBlacklistServerName, error ) ); |
|
272 |
|
273 delete cleanup; |
|
274 __UHEAP_MARKEND; |
|
275 |
|
276 WRITELOG( "CBlacklistServer::E32Main - end" ); |
|
277 |
|
278 return 0; |
|
279 } |
|
280 |
|
281 |
|
282 // --------------------------------------------------------------------------- |
|
283 // CBlacklistServer::OpenDatabaseL() |
|
284 // --------------------------------------------------------------------------- |
|
285 // |
|
286 void CBlacklistServer::OpenDatabaseL() |
|
287 { |
|
288 WRITELOG( "CBlacklistServer::OpenDatabaseL - begin" ); |
|
289 |
|
290 if ( iDatabaseOpen ) |
|
291 { |
|
292 return; |
|
293 } |
|
294 HBufC* databasePath = HBufC::NewLC( KMaxFileName ); |
|
295 TPtr pathPtr = databasePath->Des(); |
|
296 pathPtr.Append( PathInfo::PhoneMemoryRootPath()[0] ); |
|
297 pathPtr.Append( KBlacklistDatabaseFile ); |
|
298 iSqLiteConnection->OpenDbL( pathPtr ); |
|
299 iDatabaseOpen = ETrue; |
|
300 CleanupStack::PopAndDestroy( databasePath ); |
|
301 |
|
302 // Add or remove operations when DB connection was off |
|
303 if ( iDBUpdateNeeded ) |
|
304 { |
|
305 CommitBufferedItemsL(); |
|
306 } |
|
307 |
|
308 if ( !TableExistsL() ) |
|
309 { |
|
310 CreateBlacklistTableL(); |
|
311 } |
|
312 |
|
313 LoadDatabaseToMemoryL(); |
|
314 |
|
315 // serialize it for client |
|
316 SerializeToSharedMemoryL(); |
|
317 |
|
318 WRITELOG( "CBlacklistServer::OpenDatabaseL - end" ); |
|
319 } |
|
320 |
|
321 // --------------------------------------------------------------------------- |
|
322 // CBlacklistServer::SerializeToSharedMemoryL() |
|
323 // --------------------------------------------------------------------------- |
|
324 // |
|
325 void CBlacklistServer::SerializeToSharedMemoryL() |
|
326 { |
|
327 WRITELOG( "CBlacklistServer::SerializeToSharedMemoryL - begin" ); |
|
328 |
|
329 TUint32 bufferSize = 0; |
|
330 TUint32 blacklistMemoryTableCount = iBlacklistMemoryTable.Count(); |
|
331 |
|
332 // First add size for item count |
|
333 bufferSize += CMdCSerializationBuffer::KRequiredSizeForTUint32; |
|
334 |
|
335 // Add size for items |
|
336 for ( TInt i = 0; i < blacklistMemoryTableCount; ++i ) |
|
337 { |
|
338 bufferSize += iBlacklistMemoryTable[i]->RequiredBufferSize(); |
|
339 } |
|
340 |
|
341 // create chunk |
|
342 iBlacklistServerChunk.Close(); |
|
343 iHandle++; |
|
344 HBufC* name = HBufC::NewLC( KBlacklistChunkName.iTypeLength + KMaxUintValueLength ); |
|
345 *name = KBlacklistChunkName; |
|
346 name->Des().AppendNum( iHandle ); |
|
347 User::LeaveIfError( iBlacklistServerChunk.CreateGlobal( *name, bufferSize, bufferSize ) ); |
|
348 |
|
349 CMdCSerializationBuffer* buffer = CMdCSerializationBuffer::NewLC( iBlacklistServerChunk.Base(), bufferSize ); |
|
350 |
|
351 // first inser table count |
|
352 buffer->InsertL( blacklistMemoryTableCount ); |
|
353 |
|
354 // then items |
|
355 |
|
356 for ( TInt i = 0; i < blacklistMemoryTableCount; ++i ) |
|
357 { |
|
358 // add modified and media id field |
|
359 buffer->InsertL( iBlacklistMemoryTable[i]->Modified() ); |
|
360 buffer->InsertL( iBlacklistMemoryTable[i]->MediaId() ); |
|
361 |
|
362 // add uri |
|
363 const TDesC& uri = *iBlacklistMemoryTable[i]->Uri(); |
|
364 HBufC* lcUri = HBufC::NewLC( uri.Length() ); |
|
365 lcUri->Des().Append( uri ); |
|
366 buffer->InsertL( *lcUri ); |
|
367 CleanupStack::PopAndDestroy( lcUri ); |
|
368 lcUri = NULL; |
|
369 } |
|
370 |
|
371 CleanupStack::PopAndDestroy( 2, name ); |
|
372 |
|
373 // No need to keep these items anymore |
|
374 iBlacklistMemoryTable.ResetAndDestroy(); |
|
375 |
|
376 WRITELOG( "CBlacklistServer::SerializeToSharedMemoryL - end" ); |
|
377 } |
|
378 |
|
379 // --------------------------------------------------------------------------- |
|
380 // CBlacklistServer::Handle() |
|
381 // --------------------------------------------------------------------------- |
|
382 // |
|
383 TInt CBlacklistServer::MemoryHandle() |
|
384 { |
|
385 WRITELOG( "CBlacklistServer::MemoryHandle" ); |
|
386 return iHandle; |
|
387 } |
|
388 |
|
389 // --------------------------------------------------------------------------- |
|
390 // CBlacklistServer::LoadDatabaseToMemoryL() |
|
391 // --------------------------------------------------------------------------- |
|
392 // |
|
393 void CBlacklistServer::LoadDatabaseToMemoryL() |
|
394 { |
|
395 WRITELOG( "CBlacklistServer::LoadDatabaseToMemoryL - begin" ); |
|
396 |
|
397 iBlacklistMemoryTable.ResetAndDestroy(); |
|
398 RMdsStatement statement; |
|
399 CleanupClosePushL( statement ); |
|
400 RRowData emptyRowData; |
|
401 CleanupClosePushL( emptyRowData ); |
|
402 |
|
403 iSqLiteConnection->ExecuteQueryL( KMdsBlacklistCache, statement, emptyRowData ); |
|
404 |
|
405 TPtrC ptr = TPtrC( (TUint16*)0, 0 ); |
|
406 TInt64 modified = 0; |
|
407 TUint32 mediaId = 0; |
|
408 RRowData result; |
|
409 CleanupClosePushL( result ); |
|
410 result.AppendL( TColumn( ptr ) ); |
|
411 result.AppendL( TColumn( mediaId ) ); |
|
412 result.AppendL( TColumn( modified ) ); |
|
413 while ( iSqLiteConnection->NextRowL( statement, result ) ) |
|
414 { |
|
415 result.Column( 0 ).Get( ptr ); |
|
416 result.Column( 1 ).Get( mediaId ); |
|
417 result.Column( 2 ).Get( modified ); |
|
418 AddToMemoryTableL( modified, ptr, mediaId ); |
|
419 result.Column( 0 ).Free(); |
|
420 } |
|
421 |
|
422 CleanupStack::PopAndDestroy( &result ); |
|
423 CleanupStack::PopAndDestroy( &emptyRowData ); |
|
424 CleanupStack::PopAndDestroy( &statement ); |
|
425 |
|
426 WRITELOG( "CBlacklistServer::LoadDatabaseToMemoryL - end" ); |
|
427 } |
|
428 |
|
429 // --------------------------------------------------------------------------- |
|
430 // CBlacklistServer::CreateBlacklistTableL() |
|
431 // --------------------------------------------------------------------------- |
|
432 // |
|
433 void CBlacklistServer::CreateBlacklistTableL() |
|
434 { |
|
435 WRITELOG( "CBlacklistServer::CreateBlacklistTableL - begin" ); |
|
436 |
|
437 RRowData emptyRowData; |
|
438 CleanupClosePushL( emptyRowData ); |
|
439 iSqLiteConnection->ExecuteL( KDropBlacklistTable, emptyRowData ); |
|
440 iSqLiteConnection->ExecuteL( KCreateBlacklistTable, emptyRowData ); |
|
441 CleanupStack::PopAndDestroy( &emptyRowData ); |
|
442 |
|
443 WRITELOG( "CBlacklistServer::CreateBlacklistTableL - end" ); |
|
444 } |
|
445 |
|
446 |
|
447 // --------------------------------------------------------------------------- |
|
448 // CBlacklistServer::AddToMemoryTableL |
|
449 // --------------------------------------------------------------------------- |
|
450 // |
|
451 void CBlacklistServer::AddToMemoryTableL( const TInt64& aModified, |
|
452 const TDesC& aUri, const TUint32 aMediaId ) |
|
453 { |
|
454 |
|
455 WRITELOG( "CBlacklistServer::AddToMemoryTableL - begin" ); |
|
456 |
|
457 CBlacklistItem* item = CBlacklistItem::NewL( aModified, aUri, aMediaId ); |
|
458 const TInt err = iBlacklistMemoryTable.Append( item ); // ownership is transferred |
|
459 if ( err != KErrNone ) |
|
460 { |
|
461 delete item; |
|
462 } |
|
463 |
|
464 WRITELOG( "CBlacklistServer::AddToMemoryTableL - end" ); |
|
465 } |
|
466 |
|
467 // --------------------------------------------------------------------------- |
|
468 // CBlacklistServer::RemoveFromMemoryTable() |
|
469 // --------------------------------------------------------------------------- |
|
470 // |
|
471 void CBlacklistServer::RemoveFromMemoryTable( const TDesC& aUri, |
|
472 const TUint32 aMediaId ) |
|
473 { |
|
474 |
|
475 WRITELOG( "CBlacklistServer::RemoveFromMemoryTable - begin" ); |
|
476 |
|
477 TInt index = GetMemoryTableIndex( aUri, aMediaId ); |
|
478 if ( index >= 0 ) |
|
479 { |
|
480 CBlacklistItem * item = iBlacklistMemoryTable[index]; |
|
481 delete item; |
|
482 iBlacklistMemoryTable.Remove( index ); |
|
483 } |
|
484 |
|
485 WRITELOG( "CBlacklistServer::RemoveFromMemoryTable - end" ); |
|
486 } |
|
487 |
|
488 // --------------------------------------------------------------------------- |
|
489 // CBlacklistServer::GetMemoryTableIndex() |
|
490 // --------------------------------------------------------------------------- |
|
491 // |
|
492 TInt CBlacklistServer::GetMemoryTableIndex( const TDesC& aUri, TUint32 aMediaId ) |
|
493 { |
|
494 WRITELOG( "CBlacklistServer::GetMemoryTableIndex - begin" ); |
|
495 |
|
496 for ( TInt i( 0 ); i < iBlacklistMemoryTable.Count(); ++i ) |
|
497 { |
|
498 if ( iBlacklistMemoryTable[i]->Compare( aUri, aMediaId ) ) |
|
499 { |
|
500 return i; |
|
501 } |
|
502 } |
|
503 |
|
504 WRITELOG( "CBlacklistServer::GetMemoryTableIndex - end" ); |
|
505 return KErrNotFound; |
|
506 } |
|
507 |
|
508 // --------------------------------------------------------------------------- |
|
509 // CBlacklistServer::TableExistsL() |
|
510 // --------------------------------------------------------------------------- |
|
511 // |
|
512 TBool CBlacklistServer::TableExistsL() |
|
513 { |
|
514 WRITELOG( "CBlacklistServer::TableExistsL - begin" ); |
|
515 |
|
516 RMdsStatement validationQuery; |
|
517 CleanupClosePushL( validationQuery ); |
|
518 RRowData emptyRowData; |
|
519 CleanupClosePushL( emptyRowData ); |
|
520 TRAPD( err, iSqLiteConnection->ExecuteQueryL( |
|
521 KMdsBlacklistCheckTableExistence, validationQuery, emptyRowData ) ); |
|
522 validationQuery.Close(); |
|
523 CleanupStack::PopAndDestroy( &emptyRowData ); // emptyRowData |
|
524 CleanupStack::PopAndDestroy( &validationQuery ); // validationQuery |
|
525 |
|
526 WRITELOG( "CBlacklistServer::TableExistsL - end" ); |
|
527 |
|
528 return ( err == KErrNone ); |
|
529 } |
|
530 |
|
531 // --------------------------------------------------------------------------- |
|
532 // CBlacklistServer::NewSessionL() |
|
533 // --------------------------------------------------------------------------- |
|
534 // |
|
535 CSession2* CBlacklistServer::NewSessionL( const TVersion& aVersion, const RMessage2& /*aMessage*/ ) const |
|
536 { |
|
537 WRITELOG( "CBlacklistServer::NewSessionL - begin" ); |
|
538 |
|
539 // Check we are the right version |
|
540 if ( !User::QueryVersionSupported( TVersion( KBlacklistServerMajorVersion, |
|
541 KBlacklistServerMinorVersion, |
|
542 KBlacklistServerBuildVersion ), |
|
543 aVersion ) ) |
|
544 { |
|
545 User::Leave( KErrNotSupported ); |
|
546 } |
|
547 |
|
548 WRITELOG( "CBlacklistServer::NewSessionL - end" ); |
|
549 |
|
550 return new( ELeave ) CBlacklistSession; |
|
551 } |
|
552 |
|
553 // --------------------------------------------------------------------------- |
|
554 // CBlacklistServer::RunError() |
|
555 // --------------------------------------------------------------------------- |
|
556 // |
|
557 TInt CBlacklistServer::RunError( TInt aError ) |
|
558 { |
|
559 WRITELOG1( "CBlacklistServer::RunError - begin, error %d", aError ); |
|
560 |
|
561 // Bad descriptor implies bad client |
|
562 if ( aError == KErrBadDescriptor ) |
|
563 { |
|
564 Message().Panic( KBlacklistServerName, aError ); |
|
565 } |
|
566 else |
|
567 { |
|
568 Message().Complete( aError ); |
|
569 } |
|
570 |
|
571 // Continue handling requests |
|
572 ReStart(); |
|
573 |
|
574 WRITELOG( "CBlacklistServer::RunError - end" ); |
|
575 |
|
576 return KErrNone; |
|
577 } |
|
578 |
|
579 // --------------------------------------------------------------------------- |
|
580 // CBlacklistServer::AddSession() |
|
581 // --------------------------------------------------------------------------- |
|
582 // |
|
583 void CBlacklistServer::AddSession() |
|
584 { |
|
585 WRITELOG( "CBlacklistServer::AddSession" ); |
|
586 ++iSessionCount; |
|
587 } |
|
588 |
|
589 // --------------------------------------------------------------------------- |
|
590 // CBlacklistServer::RemoveSession() |
|
591 // --------------------------------------------------------------------------- |
|
592 // |
|
593 void CBlacklistServer::RemoveSession() |
|
594 { |
|
595 WRITELOG( "CBlacklistServer::RemoveSession - begin" ); |
|
596 |
|
597 --iSessionCount; |
|
598 |
|
599 #ifdef _DEBUG |
|
600 TRAPD ( err, WriteAllDataToDBL() ); |
|
601 #else |
|
602 TRAP_IGNORE ( WriteAllDataToDBL() ); |
|
603 #endif |
|
604 WRITELOG1( "CBlacklistServer::RemoveSession - err %d", err ); |
|
605 |
|
606 if ( iSessionCount == 0 ) |
|
607 { |
|
608 CActiveScheduler::Stop(); |
|
609 } |
|
610 |
|
611 WRITELOG( "CBlacklistServer::RemoveSession - end" ); |
|
612 } |
|
613 |
|
614 // --------------------------------------------------------------------------- |
|
615 // CBlacklistServer::AddL() |
|
616 // --------------------------------------------------------------------------- |
|
617 // |
|
618 void CBlacklistServer::AddL( const TUint32& mediaId, const TDesC& aUri, const TTime& aLastModifiedTime ) |
|
619 { |
|
620 WRITELOG( "CBlacklistServer::AddL - begin" ); |
|
621 |
|
622 AddToMemoryTableL( aLastModifiedTime.Int64(), aUri, mediaId ); |
|
623 |
|
624 WRITELOG( "CBlacklistServer::AddL - end" ); |
|
625 } |
|
626 |
|
627 // --------------------------------------------------------------------------- |
|
628 // CBlacklistServer::RemoveL() |
|
629 // --------------------------------------------------------------------------- |
|
630 // |
|
631 void CBlacklistServer::RemoveL( const TUint32& mediaId, const TDesC& aUri ) |
|
632 { |
|
633 WRITELOG( "CBlacklistServer::RemoveL - begin" ); |
|
634 |
|
635 RemoveFromMemoryTable( aUri, mediaId ); |
|
636 |
|
637 WRITELOG( "CBlacklistServer::RemoveL - end" ); |
|
638 } |
|
639 |
|
640 // --------------------------------------------------------------------------- |
|
641 // CBlacklistServer::RemoveFromDBL() |
|
642 // --------------------------------------------------------------------------- |
|
643 // |
|
644 void CBlacklistServer::RemoveFromDBL( const TDesC& aUri, const TUint32 aMediaId ) |
|
645 { |
|
646 WRITELOG( "CBlacklistServer::RemoveFromDBL - begin" ); |
|
647 |
|
648 RRowData* variables = new ( ELeave ) RRowData(); |
|
649 CleanupStack::PushL( variables ); |
|
650 CleanupClosePushL( *variables ); |
|
651 |
|
652 if ( !iDatabaseOpen ) |
|
653 { |
|
654 // Add it to buffer, delete from database when DB connection opens |
|
655 |
|
656 HBufC* lcBuf = aUri.AllocLC(); |
|
657 |
|
658 variables->AppendL( TColumn( lcBuf ) ); |
|
659 variables->AppendL( TColumn( aMediaId ) ); |
|
660 |
|
661 iBufferedRemoveItems.Append( variables ); // transfer ownership |
|
662 iDBUpdateNeeded = ETrue; |
|
663 CleanupStack::Pop( lcBuf ); |
|
664 CleanupStack::Pop( 2, variables ); |
|
665 } |
|
666 else |
|
667 { |
|
668 // Database open, commit to DB |
|
669 |
|
670 variables->AppendL( TColumn( aUri ) ); |
|
671 variables->AppendL( TColumn( aMediaId ) ); |
|
672 |
|
673 iSqLiteConnection->ExecuteL( KMdsBlacklistDelete, *variables ); |
|
674 CleanupStack::PopAndDestroy( 2, variables ); |
|
675 } |
|
676 |
|
677 WRITELOG( "CBlacklistServer::RemoveFromDBL - end" ); |
|
678 } |
|
679 |
|
680 |
|
681 // --------------------------------------------------------------------------- |
|
682 // CBlacklistServer::AddDBL() |
|
683 // --------------------------------------------------------------------------- |
|
684 // |
|
685 void CBlacklistServer::AddToDBL( const TDesC& aUri, const TUint32 aMediaId, |
|
686 const TInt64& aLastModifiedTime ) |
|
687 { |
|
688 WRITELOG( "CBlacklistServer::AddToDBL - begin" ); |
|
689 |
|
690 RRowData* rowData = new ( ELeave ) RRowData(); |
|
691 CleanupStack::PushL( rowData ); |
|
692 CleanupClosePushL( *rowData ); |
|
693 |
|
694 if ( !iDatabaseOpen ) |
|
695 { |
|
696 // Add it to buffer, add to database when DB connection opens |
|
697 HBufC* lcBuf = aUri.AllocLC(); |
|
698 |
|
699 rowData->AppendL( TColumn( aLastModifiedTime ) ); |
|
700 rowData->AppendL( TColumn( lcBuf ) ); |
|
701 rowData->AppendL( TColumn( aMediaId ) ); |
|
702 |
|
703 iBufferedAddedItems.Append( rowData ); // transfer ownership |
|
704 iDBUpdateNeeded = ETrue; |
|
705 CleanupStack::Pop( lcBuf ); |
|
706 CleanupStack::Pop( 2, rowData ); |
|
707 } |
|
708 else |
|
709 { |
|
710 rowData->AppendL( TColumn( aLastModifiedTime ) ); |
|
711 rowData->AppendL( TColumn( aUri ) ); |
|
712 rowData->AppendL( TColumn( aMediaId ) ); |
|
713 |
|
714 TRAPD( err, iSqLiteConnection->ExecuteL( KMdsBlacklistInsert, *rowData ) ); |
|
715 if ( err == KSqlErrConstraint ) // is the file already blacklisted... |
|
716 { |
|
717 iSqLiteConnection->ExecuteL( KMdsBlacklistUpdate, *rowData ); |
|
718 } |
|
719 CleanupStack::PopAndDestroy( 2, rowData ); |
|
720 } |
|
721 |
|
722 WRITELOG( "CBlacklistServer::AddToDBL - end" ); |
|
723 } |
|
724 |
|
725 // --------------------------------------------------------------------------- |
|
726 // CBlacklistServer::WriteAllDataToDBL() |
|
727 // --------------------------------------------------------------------------- |
|
728 // |
|
729 void CBlacklistServer::WriteAllDataToDBL() |
|
730 { |
|
731 WRITELOG( "CBlacklistServer::WriteAllDataToDBL - begin" ); |
|
732 |
|
733 for ( TInt i( 0 ); i < iBlacklistMemoryTable.Count(); ++i ) |
|
734 { |
|
735 AddToDBL( *iBlacklistMemoryTable[i]->Uri(), iBlacklistMemoryTable[i]->MediaId(), iBlacklistMemoryTable[i]->Modified() ); |
|
736 } |
|
737 |
|
738 WRITELOG( "CBlacklistServer::WriteAllDataToDBL - end" ); |
|
739 } |
|
740 |
|
741 // --------------------------------------------------------------------------- |
|
742 // CBlacklistServer::WriteAllDataToDBL() |
|
743 // --------------------------------------------------------------------------- |
|
744 // |
|
745 void CBlacklistServer::CommitBufferedItemsL() |
|
746 { |
|
747 WRITELOG( "CBlacklistServer::CommitBufferedItemsL - begin" ); |
|
748 |
|
749 // First, removed items |
|
750 for ( TInt i( 0 ); i < iBufferedRemoveItems.Count(); ++i ) |
|
751 { |
|
752 iSqLiteConnection->ExecuteL( KMdsBlacklistDelete, *iBufferedRemoveItems[i] ); |
|
753 iBufferedRemoveItems[i]->Column( 0 ).Free(); |
|
754 } |
|
755 |
|
756 // Second, added items |
|
757 for ( TInt i( 0 ); i < iBufferedAddedItems.Count(); ++i ) |
|
758 { |
|
759 iSqLiteConnection->ExecuteL( KMdsBlacklistUpdate, *iBufferedAddedItems[i] ); |
|
760 iBufferedAddedItems[i]->Column( 0 ).Free(); |
|
761 } |
|
762 |
|
763 WRITELOG( "CBlacklistServer::CommitBufferedItemsL - end" ); |
|
764 } |
|
765 |
|
766 // End of File |