|
1 // Copyright (c) 1997-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 "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 // |
|
15 |
|
16 /** |
|
17 @file |
|
18 */ |
|
19 |
|
20 |
|
21 #include "database.h" |
|
22 #include "dbdef.h" |
|
23 #include "filedump.h" |
|
24 #include <etelqos.h> |
|
25 #include <etelmm.h> |
|
26 #include <etelpckt.h> |
|
27 #include <faxdefn.h> |
|
28 #include "T_tabdef.h" |
|
29 #include "input.h" |
|
30 #include <networking/panroles.h> |
|
31 #include <nifvar_internal.h> |
|
32 |
|
33 #include <e32hashtab.h> |
|
34 |
|
35 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS |
|
36 #include <commsdattypesv1_1_partner.h> |
|
37 #include <commsdattypesv1_1_internal.h> |
|
38 #include <nifvar_internal.h> |
|
39 #endif |
|
40 |
|
41 /** |
|
42 makes logging accessible to all files |
|
43 */ |
|
44 extern CFileDump* gMsg; |
|
45 /** |
|
46 text for local error codes |
|
47 @internalComponent |
|
48 */ |
|
49 TPtrC errorCode[] = { |
|
50 _L("Not all required field data supplied"), //< E_NOTENOUGHDATA |
|
51 _L("Command not possible in this transaction state"), //< E_INVALIDCOMMAND |
|
52 _L("Field data supplied has incorrect data type"), //< E_INCORRECTTYPE |
|
53 _L("Column data is invalid for the last written column's type"), //< E_INCORRECTCOLNAME |
|
54 _L("Object already exists"), //< E_ALREADYEXISTS |
|
55 _L("Enumeration supplied is incorrect for this field"), //< E_INCORRECTENUM |
|
56 _L("Incorrect number of Agent fields supplied"), //< E_INCORRECTAGENT |
|
57 _L("Field count does not match expected amount"), //< E_BADFIELDCOUNT |
|
58 _L("No fields recognised"), //< E_NOFIELDS |
|
59 _L("Not supported"), //< E_NOTSUPPORTED |
|
60 _L("No Global Settings specified"), //< E_INCORRECTGLOBAL |
|
61 _L("Bad escaped character"), //< E_BADESCAPEDCHAR |
|
62 _L("Bad hexadecimal") //< E_BADHEXADECIMAL |
|
63 }; |
|
64 |
|
65 #define KTableLinkSeparator _S("Link") |
|
66 |
|
67 |
|
68 DBAccess::DBAccess(const TBool aXML) |
|
69 : |
|
70 iSecure(EFalse), |
|
71 iCommitIndividualRecords(EFalse), |
|
72 iIsMeshFileProcessing(EFalse), |
|
73 access(DBUnknown), |
|
74 iLastError(KErrNone), |
|
75 LastErrorMessage(_L("")), |
|
76 FieldCountExpected(0), |
|
77 iColCount(0), |
|
78 i2000PacketServiceTable(1), |
|
79 iInAppendMode(0), |
|
80 iIsXML(aXML), |
|
81 iLnkByTagRes(NULL) |
|
82 { |
|
83 } |
|
84 |
|
85 |
|
86 DBAccess::~DBAccess() |
|
87 { |
|
88 Close(); |
|
89 CloseTable(); |
|
90 iRecordSetHolder.ResetAndDestroy(); |
|
91 } |
|
92 |
|
93 void DBAccess::InitCommsdatL() |
|
94 { |
|
95 #ifdef __COMMDB_ROHID_SUPPORT__ |
|
96 iSecure = ETrue; |
|
97 #endif |
|
98 |
|
99 #ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY |
|
100 if (iIsMeshFileProcessing) |
|
101 { |
|
102 //in this case no mapper is needed. |
|
103 iDbSession = CMDBSession::NewL(KCDVersion1_2); |
|
104 } |
|
105 else |
|
106 { |
|
107 iDbSession = CMDBSession::NewL(KCDVersion1_1); |
|
108 } |
|
109 #else |
|
110 iDbSession = CMDBSession::NewL(KCDVersion1_1); |
|
111 #endif |
|
112 iDbSession->SetAttributeMask(ECDHidden | ECDPrivate | ECDProtectedWrite |ECDNoWriteButDelete ); |
|
113 } |
|
114 |
|
115 void DBAccess::MaybeBeginTransactionL() |
|
116 { |
|
117 if(!iDbSession->IsInTransaction()) |
|
118 { |
|
119 iDbSession->OpenTransactionL(); |
|
120 } |
|
121 } |
|
122 |
|
123 TInt DBAccess::CommitTransaction() |
|
124 { |
|
125 TInt ret = KErrNone; |
|
126 if(iDbSession && iDbSession->IsInTransaction()) |
|
127 { |
|
128 TRAP(ret, iDbSession->CommitTransactionL()); |
|
129 iRecordSetHolder.ResetAndDestroy(); |
|
130 } |
|
131 return ret; |
|
132 } |
|
133 |
|
134 void DBAccess::Close() |
|
135 { |
|
136 if(iDbSession) |
|
137 { |
|
138 delete iDbSession; |
|
139 iDbSession = NULL; |
|
140 } |
|
141 } |
|
142 |
|
143 |
|
144 void DBAccess::CloseTable() |
|
145 /** |
|
146 Closes the table |
|
147 */ |
|
148 { |
|
149 if(iTable) |
|
150 { |
|
151 iTable->iRecords.ResetAndDestroy(); |
|
152 iTable->iRecords.Close(); |
|
153 |
|
154 delete iTable; |
|
155 iTable = NULL; |
|
156 iTableId = 0; |
|
157 } |
|
158 } |
|
159 |
|
160 |
|
161 TInt DBAccess::CommitChanges() |
|
162 /** |
|
163 Finalise changes to database |
|
164 |
|
165 @return ETrue if successful or EFalse |
|
166 */ |
|
167 { |
|
168 TInt ret = KErrNone; |
|
169 if(iTable) |
|
170 { |
|
171 gMsg->Dbg(_L(" Committing record")); |
|
172 // ****** |
|
173 // Modify, don't store as if appending don't know what will already be there. |
|
174 // This was introduced with meshpreface file helping migration to new |
|
175 // comms framework, but is generally useful idea |
|
176 // TRAP(ret, iTable->ModifyL(*iDbSession)); |
|
177 // ****** |
|
178 |
|
179 /** |
|
180 only for testing... |
|
181 CCDConnectionPrefsRecord* elem = NULL; |
|
182 TInt elemId = iTable->iRecords[0]->ElementId(); |
|
183 if ( (elemId & KCDMaskShowRecordType) == KCDTIdConnectionPrefsRecord) |
|
184 { |
|
185 elem = static_cast<CCDConnectionPrefsRecord*>(iTable->iRecords[0]); |
|
186 } |
|
187 */ |
|
188 TRAP(ret, iTable->StoreL(*iDbSession)); |
|
189 if(ret == KErrNone && iDbSession->IsInTransaction()) |
|
190 { |
|
191 ret = iRecordSetHolder.Append(iTable); |
|
192 } |
|
193 else |
|
194 { |
|
195 delete iTable; |
|
196 } |
|
197 iTable = NULL; |
|
198 } |
|
199 return ret; |
|
200 } |
|
201 |
|
202 // PRIVATE METHODS |
|
203 |
|
204 void DBAccess::RemoveCurrentRecord() |
|
205 { |
|
206 CMDBRecordBase* tempptr = iTable->iRecords[iTable->iRecords.Count()-1]; |
|
207 delete tempptr; |
|
208 |
|
209 iTable->iRecords.Remove(iTable->iRecords.Count()-1); |
|
210 |
|
211 if(iRecordId) |
|
212 { |
|
213 iRecordId = iRecordId - 1; |
|
214 } |
|
215 } |
|
216 |
|
217 |
|
218 CMDBRecordBase* DBAccess::GetCurrentRecord() |
|
219 { |
|
220 return (iTable->iRecords[iTable->iRecords.Count()-1]); |
|
221 } |
|
222 |
|
223 void DBAccess::RecordIsTemplate(TBool aIsTemplate) |
|
224 { |
|
225 iIsTemplate = aIsTemplate; |
|
226 if(iIsTemplate) |
|
227 { |
|
228 iConfusingTemplateBehaviour = iIsTemplate; |
|
229 } |
|
230 } |
|
231 |
|
232 void DBAccess::DoInitAndAddL(CCDRecordBase* aNewRecord,TInt aRecordId) |
|
233 { |
|
234 iColCount = 0; |
|
235 |
|
236 if(iIsTemplate) |
|
237 { |
|
238 aNewRecord->SetRecordId(KCDDefaultRecord); |
|
239 aNewRecord->SetAttributes(ECDHidden); |
|
240 } |
|
241 else if(iInAppendMode) |
|
242 { |
|
243 if (!iIsXML) |
|
244 { |
|
245 //We are appending and we don't have a clue about what record ids are already in use |
|
246 //So we ask CommsDat to give us an unused one. |
|
247 aNewRecord->SetRecordId(KCDNewRecordRequest); |
|
248 User::LeaveIfError(iTable->iRecords.Append(aNewRecord)); |
|
249 return; |
|
250 } |
|
251 else |
|
252 /** |
|
253 * When CED is processing XML files it always has recordIDs. |
|
254 */ |
|
255 aNewRecord->SetRecordId(aRecordId); |
|
256 } |
|
257 else if(aRecordId) |
|
258 { |
|
259 aNewRecord->SetRecordId(aRecordId); |
|
260 iRecordId = aRecordId + 1; |
|
261 } |
|
262 else if(!iTable->iRecords.Count()) |
|
263 { |
|
264 //general case where template records are missing |
|
265 aNewRecord->SetRecordId(iRecordId); |
|
266 iRecordId = iRecordId + 1; |
|
267 } |
|
268 else |
|
269 { |
|
270 if(iConfusingTemplateBehaviour && iRecordId == 1) |
|
271 { |
|
272 iRecordId = iRecordId + 1; |
|
273 } |
|
274 |
|
275 aNewRecord->SetRecordId(iRecordId); |
|
276 iRecordId = iRecordId + 1; |
|
277 } |
|
278 |
|
279 // Check whether we've already inserted this record id - if so then we must reject it as a duplicate, |
|
280 // lest the database roll back the entire transaction (its behaviour at present) |
|
281 TInt newRecordId = aNewRecord->RecordId(); |
|
282 for(TInt idx = iTable->iRecords.Count() - 1; idx >= 0; --idx) |
|
283 { |
|
284 if(iTable->iRecords[idx]->RecordId() == newRecordId) |
|
285 { |
|
286 gMsg->Msg(_L("ERR: record id %d already inserted, skipping (check input file)"), newRecordId); |
|
287 delete aNewRecord; |
|
288 return; |
|
289 } |
|
290 } |
|
291 |
|
292 User::LeaveIfError(iTable->iRecords.Append(aNewRecord)); |
|
293 } |
|
294 |
|
295 void DBAccess::InitAndAddL(CCDRecordBase* aNewRecord,TInt aRecordId) |
|
296 { |
|
297 CleanupStack::PushL(aNewRecord); |
|
298 DoInitAndAddL(aNewRecord,aRecordId); |
|
299 CleanupStack::Pop(aNewRecord); |
|
300 } |
|
301 |
|
302 void DBAccess::SaveTableProtection(CMDBRecordSetBase* aRecordSet) |
|
303 { |
|
304 CloseTable(); |
|
305 iTable = (CMDBRecordSetBase*)aRecordSet; |
|
306 } |
|
307 |
|
308 void DBAccess::CreateOrInsertRecordL(TCreateType aType,TMDBElementId aRecordElementId, TInt aRecordId) |
|
309 /* |
|
310 This method returns the pointer to recordset type depending on record Id |
|
311 */ |
|
312 { |
|
313 if(aType == EInsert && iTable->iRecords.Count() >= KCDMaxRecords) |
|
314 { |
|
315 User::Leave(KErrTooBig); //actually KErrTooManyRecords |
|
316 } |
|
317 |
|
318 if(aType != EInsert) |
|
319 { |
|
320 if(aType == ECreateNew) |
|
321 { |
|
322 iRecordId = 1; |
|
323 } |
|
324 iTableId = aRecordElementId; |
|
325 } |
|
326 |
|
327 iNameSet = EFalse; |
|
328 |
|
329 switch(iTableId) |
|
330 { |
|
331 case KCDTIdConnectionPrefsRecord: |
|
332 { |
|
333 if(aType != EInsert) |
|
334 { |
|
335 CMDBRecordSet<CCDConnectionPrefsRecord>* ptrRecordSet = new (ELeave)CMDBRecordSet<CCDConnectionPrefsRecord>(KCDTIdConnectionPrefsRecord); |
|
336 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
337 } |
|
338 else |
|
339 { |
|
340 CCDConnectionPrefsRecord* ptrNewRecord = (CCDConnectionPrefsRecord*)CCDRecordBase::RecordFactoryL(KCDTIdConnectionPrefsRecord); |
|
341 InitAndAddL(ptrNewRecord,aRecordId); |
|
342 } |
|
343 } |
|
344 break; |
|
345 |
|
346 case KCDTIdIAPRecord: |
|
347 if(aType != EInsert) |
|
348 { |
|
349 CMDBRecordSet<CCDIAPRecord>* ptrRecordSet = new (ELeave)CMDBRecordSet<CCDIAPRecord>(KCDTIdIAPRecord); |
|
350 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
351 } |
|
352 else |
|
353 { |
|
354 CCDIAPRecord* ptrNewRecord = (CCDIAPRecord*)CCDRecordBase::RecordFactoryL(KCDTIdIAPRecord); |
|
355 InitAndAddL(ptrNewRecord,aRecordId); |
|
356 } |
|
357 break; |
|
358 |
|
359 case KCDTIdNetworkRecord: |
|
360 if(aType != EInsert) |
|
361 { |
|
362 CMDBRecordSet<CCDNetworkRecord>* ptrRecordSet = new (ELeave)CMDBRecordSet<CCDNetworkRecord>(KCDTIdNetworkRecord); |
|
363 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
364 } |
|
365 else |
|
366 { |
|
367 CCDNetworkRecord* ptrNewRecord = (CCDNetworkRecord*)CCDRecordBase::RecordFactoryL(KCDTIdNetworkRecord); |
|
368 InitAndAddL(ptrNewRecord,aRecordId); |
|
369 } |
|
370 break; |
|
371 |
|
372 case KCDTIdLocationRecord: |
|
373 if(aType != EInsert) |
|
374 { |
|
375 CMDBRecordSet<CCDLocationRecord>* ptrRecordSet = new (ELeave)CMDBRecordSet<CCDLocationRecord>(KCDTIdLocationRecord | 1); |
|
376 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
377 } |
|
378 else |
|
379 { |
|
380 CCDLocationRecord* ptrNewRecord = (CCDLocationRecord*)CCDRecordBase::RecordFactoryL(KCDTIdLocationRecord); |
|
381 InitAndAddL(ptrNewRecord,aRecordId); |
|
382 } |
|
383 break; |
|
384 |
|
385 |
|
386 case KCDTIdGlobalSettingsRecord: |
|
387 if(aType != EInsert) |
|
388 { |
|
389 CMDBRecordSet<CCDGlobalSettingsRecord>* ptrRecordSet = new (ELeave)CMDBRecordSet<CCDGlobalSettingsRecord>(KCDTIdGlobalSettingsRecord); |
|
390 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
391 } |
|
392 else |
|
393 { |
|
394 CCDGlobalSettingsRecord* ptrNewRecord = (CCDGlobalSettingsRecord*)CCDRecordBase::RecordFactoryL(KCDTIdGlobalSettingsRecord); |
|
395 InitAndAddL(ptrNewRecord,aRecordId); |
|
396 } |
|
397 break; |
|
398 |
|
399 case KCDTIdWAPAccessPointRecord: |
|
400 if(aType != EInsert) |
|
401 { |
|
402 CMDBRecordSet<CCDWAPAccessPointRecord>* ptrRecordSet = new (ELeave)CMDBRecordSet<CCDWAPAccessPointRecord>(KCDTIdWAPAccessPointRecord); |
|
403 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
404 } |
|
405 else |
|
406 { |
|
407 CCDWAPAccessPointRecord* ptrNewRecord = (CCDWAPAccessPointRecord*)CCDRecordBase::RecordFactoryL(KCDTIdWAPAccessPointRecord); |
|
408 InitAndAddL(ptrNewRecord,aRecordId); |
|
409 } |
|
410 break; |
|
411 |
|
412 case KCDTIdDialOutISPRecord: |
|
413 if(aType != EInsert) |
|
414 { |
|
415 CMDBRecordSet<CCDDialOutISPRecord>* ptrRecordSet = new (ELeave)CMDBRecordSet<CCDDialOutISPRecord>(KCDTIdDialOutISPRecord); |
|
416 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
417 } |
|
418 else |
|
419 { |
|
420 CCDDialOutISPRecord* ptrNewRecord = (CCDDialOutISPRecord*)CCDRecordBase::RecordFactoryL(KCDTIdDialOutISPRecord); |
|
421 InitAndAddL(ptrNewRecord,aRecordId); |
|
422 } |
|
423 break; |
|
424 |
|
425 case KCDTIdDialInISPRecord: |
|
426 if(aType != EInsert) |
|
427 { |
|
428 CMDBRecordSet<CCDDialInISPRecord>* ptrRecordSet = new (ELeave)CMDBRecordSet<CCDDialInISPRecord>(KCDTIdDialInISPRecord); |
|
429 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
430 } |
|
431 else |
|
432 { |
|
433 CCDDialInISPRecord* ptrNewRecord = (CCDDialInISPRecord*)CCDRecordBase::RecordFactoryL(KCDTIdDialInISPRecord); |
|
434 InitAndAddL(ptrNewRecord,aRecordId); |
|
435 } |
|
436 break; |
|
437 |
|
438 case KCDTIdLANServiceRecord: |
|
439 if(aType != EInsert) |
|
440 { |
|
441 CMDBRecordSet<CCDLANServiceRecord>* ptrRecordSet = new (ELeave)CMDBRecordSet<CCDLANServiceRecord>(KCDTIdLANServiceRecord); |
|
442 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
443 } |
|
444 else |
|
445 { |
|
446 CCDLANServiceRecord* ptrNewRecord = (CCDLANServiceRecord*)CCDRecordBase::RecordFactoryL(KCDTIdLANServiceRecord); |
|
447 InitAndAddL(ptrNewRecord,aRecordId); |
|
448 } |
|
449 break; |
|
450 |
|
451 case KCDTIdWLANServiceExtRecord: |
|
452 if(aType != EInsert) |
|
453 { |
|
454 CMDBRecordSet<CCDWLANServiceExtRecord>* ptrRecordSet = new (ELeave)CMDBRecordSet<CCDWLANServiceExtRecord>(KCDTIdWLANServiceExtRecord); |
|
455 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
456 } |
|
457 else |
|
458 { |
|
459 CCDWLANServiceExtRecord* ptrNewRecord = (CCDWLANServiceExtRecord*)CCDRecordBase::RecordFactoryL(KCDTIdWLANServiceExtRecord); |
|
460 InitAndAddL(ptrNewRecord,aRecordId); |
|
461 } |
|
462 break; |
|
463 |
|
464 case KCDTIdVPNServiceRecord: |
|
465 if(aType != EInsert) |
|
466 { |
|
467 CMDBRecordSet<CCDVPNServiceRecord>* ptrRecordSet = new (ELeave)CMDBRecordSet<CCDVPNServiceRecord>(KCDTIdVPNServiceRecord); |
|
468 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
469 } |
|
470 else |
|
471 { |
|
472 CCDVPNServiceRecord* ptrNewRecord = (CCDVPNServiceRecord*)CCDRecordBase::RecordFactoryL(KCDTIdVPNServiceRecord); |
|
473 InitAndAddL(ptrNewRecord,aRecordId); |
|
474 } |
|
475 break; |
|
476 |
|
477 case KCDTIdPANServiceExtRecord: |
|
478 if(aType != EInsert) |
|
479 { |
|
480 CMDBRecordSet<CCDPANServiceExtRecord>* ptrRecordSet = new (ELeave)CMDBRecordSet<CCDPANServiceExtRecord>(KCDTIdPANServiceExtRecord); |
|
481 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
482 } |
|
483 else |
|
484 { |
|
485 CCDPANServiceExtRecord* ptrNewRecord = (CCDPANServiceExtRecord*)CCDRecordBase::RecordFactoryL(KCDTIdPANServiceExtRecord); |
|
486 InitAndAddL(ptrNewRecord,aRecordId); |
|
487 } |
|
488 break; |
|
489 |
|
490 |
|
491 case KCDTIdWCDMAPacketServiceRecord: |
|
492 if(aType != EInsert) |
|
493 { |
|
494 CMDBRecordSet<CCDWCDMAPacketServiceRecord>* ptrRecordSet = new (ELeave)CMDBRecordSet<CCDWCDMAPacketServiceRecord>(KCDTIdWCDMAPacketServiceRecord); |
|
495 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
496 iRecordId = i2000PacketServiceTable; |
|
497 } |
|
498 else |
|
499 { |
|
500 CCDWCDMAPacketServiceRecord* ptrNewRecord = (CCDWCDMAPacketServiceRecord*)CCDRecordBase::RecordFactoryL(KCDTIdWCDMAPacketServiceRecord); |
|
501 if(i2000PacketServiceTable == 1) |
|
502 { |
|
503 InitAndAddL(ptrNewRecord,aRecordId); |
|
504 } |
|
505 else |
|
506 { |
|
507 InitAndAddL(ptrNewRecord,i2000PacketServiceTable); |
|
508 } |
|
509 i2000PacketServiceTable = iRecordId; |
|
510 } |
|
511 break; |
|
512 case KCDTIdOutgoingGprsRecord: |
|
513 if(aType != EInsert) |
|
514 { |
|
515 CMDBRecordSet<CCDOutgoingGprsRecord>* ptrRecordSet = new (ELeave)CMDBRecordSet<CCDOutgoingGprsRecord>(KCDTIdOutgoingGprsRecord); |
|
516 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
517 } |
|
518 else |
|
519 { |
|
520 CCDOutgoingGprsRecord* ptrNewRecord = (CCDOutgoingGprsRecord*)CCDRecordBase::RecordFactoryL(KCDTIdOutgoingGprsRecord); |
|
521 InitAndAddL(ptrNewRecord,aRecordId); |
|
522 } |
|
523 break; |
|
524 case KCDTIdIncomingGprsRecord: |
|
525 if(aType != EInsert) |
|
526 { |
|
527 CMDBRecordSet<CCDIncomingGprsRecord>* ptrRecordSet = new (ELeave)CMDBRecordSet<CCDIncomingGprsRecord>(KCDTIdIncomingGprsRecord); |
|
528 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
529 } |
|
530 else |
|
531 { |
|
532 CCDIncomingGprsRecord* ptrNewRecord = (CCDIncomingGprsRecord*)CCDRecordBase::RecordFactoryL(KCDTIdIncomingGprsRecord); |
|
533 InitAndAddL(ptrNewRecord,aRecordId); |
|
534 } |
|
535 break; |
|
536 |
|
537 case KCDTIdUmtsR99QoSAndOnTableRecord: |
|
538 if(aType != EInsert) |
|
539 { |
|
540 CMDBRecordSet<CCDUmtsR99QoSAndOnTableRecord>* ptrRecordSet = new (ELeave)CMDBRecordSet<CCDUmtsR99QoSAndOnTableRecord>(KCDTIdUmtsR99QoSAndOnTableRecord); |
|
541 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
542 } |
|
543 else |
|
544 { |
|
545 CCDUmtsR99QoSAndOnTableRecord* ptrNewRecord = static_cast<CCDUmtsR99QoSAndOnTableRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdUmtsR99QoSAndOnTableRecord)); |
|
546 InitAndAddL(ptrNewRecord,aRecordId); |
|
547 } |
|
548 break; |
|
549 |
|
550 case KCDTIdDefaultWCDMARecord: |
|
551 |
|
552 if(aType != EInsert) |
|
553 { |
|
554 CMDBRecordSet<CCDDefaultWCDMARecord>* ptrRecordSet = new (ELeave)CMDBRecordSet<CCDDefaultWCDMARecord>(KCDTIdDefaultWCDMARecord); |
|
555 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
556 } |
|
557 else |
|
558 { |
|
559 CCDDefaultWCDMARecord* ptrNewRecord = (CCDDefaultWCDMARecord*)CCDRecordBase::RecordFactoryL(KCDTIdDefaultWCDMARecord); |
|
560 InitAndAddL(ptrNewRecord,aRecordId); |
|
561 } |
|
562 break; |
|
563 |
|
564 |
|
565 case KCDTIdModemBearerRecord: |
|
566 if(aType != EInsert) |
|
567 { |
|
568 CMDBRecordSet<CCDModemBearerRecord>* ptrRecordSet = new (ELeave)CMDBRecordSet<CCDModemBearerRecord>(KCDTIdModemBearerRecord); |
|
569 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
570 } |
|
571 else |
|
572 { |
|
573 CCDModemBearerRecord* ptrNewRecord = (CCDModemBearerRecord*)CCDRecordBase::RecordFactoryL(KCDTIdModemBearerRecord); |
|
574 InitAndAddL(ptrNewRecord,aRecordId); |
|
575 } |
|
576 break; |
|
577 |
|
578 case KCDTIdLANBearerRecord: |
|
579 if(aType != EInsert) |
|
580 { |
|
581 CMDBRecordSet<CCDLANBearerRecord>* ptrRecordSet = new (ELeave)CMDBRecordSet<CCDLANBearerRecord>(KCDTIdLANBearerRecord); |
|
582 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
583 } |
|
584 else |
|
585 { |
|
586 CCDLANBearerRecord* ptrNewRecord = (CCDLANBearerRecord*)CCDRecordBase::RecordFactoryL(KCDTIdLANBearerRecord); |
|
587 InitAndAddL(ptrNewRecord,aRecordId); |
|
588 } |
|
589 break; |
|
590 |
|
591 case KCDTIdVirtualBearerRecord: |
|
592 if(aType != EInsert) |
|
593 { |
|
594 CMDBRecordSet<CCDVirtualBearerRecord>* ptrRecordSet = new (ELeave)CMDBRecordSet<CCDVirtualBearerRecord>(KCDTIdVirtualBearerRecord); |
|
595 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
596 } |
|
597 else |
|
598 { |
|
599 CCDVirtualBearerRecord* ptrNewRecord = (CCDVirtualBearerRecord*)CCDRecordBase::RecordFactoryL(KCDTIdVirtualBearerRecord); |
|
600 InitAndAddL(ptrNewRecord,aRecordId); |
|
601 } |
|
602 break; |
|
603 |
|
604 case KCDTIdWAPSMSBearerRecord: |
|
605 if(aType != EInsert) |
|
606 { |
|
607 CMDBRecordSet<CCDWAPSMSBearerRecord>* ptrRecordSet = new (ELeave)CMDBRecordSet<CCDWAPSMSBearerRecord>(KCDTIdWAPSMSBearerRecord); |
|
608 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
609 } |
|
610 else |
|
611 { |
|
612 CCDWAPSMSBearerRecord* ptrNewRecord = (CCDWAPSMSBearerRecord*)CCDRecordBase::RecordFactoryL(KCDTIdWAPSMSBearerRecord); |
|
613 InitAndAddL(ptrNewRecord,aRecordId); |
|
614 } |
|
615 break; |
|
616 |
|
617 case KCDTIdWAPIPBearerRecord: |
|
618 if(aType != EInsert) |
|
619 { |
|
620 CMDBRecordSet<CCDWAPIPBearerRecord>* ptrRecordSet = new (ELeave)CMDBRecordSet<CCDWAPIPBearerRecord>(KCDTIdWAPIPBearerRecord); |
|
621 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
622 } |
|
623 else |
|
624 { |
|
625 CCDWAPIPBearerRecord* ptrNewRecord = (CCDWAPIPBearerRecord*)CCDRecordBase::RecordFactoryL(KCDTIdWAPIPBearerRecord); |
|
626 InitAndAddL(ptrNewRecord,aRecordId); |
|
627 } |
|
628 break; |
|
629 |
|
630 case KCDTIdChargecardRecord: |
|
631 if(aType != EInsert) |
|
632 { |
|
633 CMDBRecordSet<CCDChargecardRecord>* ptrRecordSet = new (ELeave)CMDBRecordSet<CCDChargecardRecord>(KCDTIdChargecardRecord); |
|
634 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
635 } |
|
636 else |
|
637 { |
|
638 CCDChargecardRecord* ptrNewRecord = (CCDChargecardRecord*)CCDRecordBase::RecordFactoryL(KCDTIdChargecardRecord); |
|
639 InitAndAddL(ptrNewRecord,aRecordId); |
|
640 } |
|
641 break; |
|
642 |
|
643 case KCDTIdProxiesRecord: |
|
644 if(aType != EInsert) |
|
645 { |
|
646 CMDBRecordSet<CCDProxiesRecord>* ptrRecordSet = new (ELeave)CMDBRecordSet<CCDProxiesRecord>(KCDTIdProxiesRecord); |
|
647 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
648 } |
|
649 else |
|
650 { |
|
651 CCDProxiesRecord* ptrNewRecord = (CCDProxiesRecord*)CCDRecordBase::RecordFactoryL(KCDTIdProxiesRecord); |
|
652 InitAndAddL(ptrNewRecord,aRecordId); |
|
653 } |
|
654 break; |
|
655 |
|
656 case KCDTIdSSProtoRecord: |
|
657 if(aType != EInsert) |
|
658 { |
|
659 CMDBRecordSet<CCDSecureSocketRecord>* ptrRecordSet = new (ELeave)CMDBRecordSet<CCDSecureSocketRecord>(KCDTIdSSProtoRecord); |
|
660 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
661 } |
|
662 else |
|
663 { |
|
664 CCDSecureSocketRecord* ptrNewRecord = (CCDSecureSocketRecord*)CCDRecordBase::RecordFactoryL(KCDTIdSSProtoRecord); |
|
665 InitAndAddL(ptrNewRecord,aRecordId); |
|
666 } |
|
667 break; |
|
668 |
|
669 case KCDTIdAgentLookupRecord: //todo exist? |
|
670 if(aType != EInsert) |
|
671 { |
|
672 CMDBRecordSet<CCDAgentLookupRecord>* ptrRecordSet = new (ELeave)CMDBRecordSet<CCDAgentLookupRecord>(KCDTIdAgentLookupRecord); |
|
673 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
674 } |
|
675 else |
|
676 { |
|
677 CCDAgentLookupRecord* ptrNewRecord = (CCDAgentLookupRecord*)CCDRecordBase::RecordFactoryL(KCDTIdAgentLookupRecord); |
|
678 InitAndAddL(ptrNewRecord,aRecordId); |
|
679 } |
|
680 break; |
|
681 |
|
682 case KCDTIdAccessPointRecord: |
|
683 if(aType != EInsert) |
|
684 { |
|
685 CMDBRecordSet<CCDAccessPointRecord>* ptrRecordSet = new (ELeave)CMDBRecordSet<CCDAccessPointRecord>(KCDTIdAccessPointRecord); |
|
686 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
687 } |
|
688 else |
|
689 { |
|
690 CCDAccessPointRecord* ptrNewRecord = (CCDAccessPointRecord*)CCDRecordBase::RecordFactoryL(KCDTIdAccessPointRecord); |
|
691 InitAndAddL(ptrNewRecord,aRecordId); |
|
692 } |
|
693 break; |
|
694 #ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY |
|
695 case KCDTIdConfigAccessPointRecord: |
|
696 if(aType != EInsert) |
|
697 { |
|
698 CMDBRecordSet<CCDConfigAccessPointRecord>* ptrRecordSet = new (ELeave)CMDBRecordSet<CCDConfigAccessPointRecord>(KCDTIdConfigAccessPointRecord); |
|
699 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
700 } |
|
701 else |
|
702 { |
|
703 CCDConfigAccessPointRecord* ptrNewRecord = (CCDConfigAccessPointRecord*)CCDRecordBase::RecordFactoryL(KCDTIdConfigAccessPointRecord); |
|
704 InitAndAddL(ptrNewRecord,aRecordId); |
|
705 } |
|
706 break; |
|
707 case KCDTIdApPrioritySelectionPolicyRecord: |
|
708 if(aType != EInsert) |
|
709 { |
|
710 CMDBRecordSet<CCDAPPrioritySelectionPolicyRecord>* ptrRecordSet = new (ELeave)CMDBRecordSet<CCDAPPrioritySelectionPolicyRecord>(KCDTIdApPrioritySelectionPolicyRecord); |
|
711 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
712 } |
|
713 else |
|
714 { |
|
715 CCDAPPrioritySelectionPolicyRecord* ptrNewRecord = (CCDAPPrioritySelectionPolicyRecord*)CCDRecordBase::RecordFactoryL(KCDTIdApPrioritySelectionPolicyRecord); |
|
716 InitAndAddL(ptrNewRecord,aRecordId); |
|
717 } |
|
718 break; |
|
719 case KCDTIdTierRecord: |
|
720 if(aType != EInsert) |
|
721 { |
|
722 CMDBRecordSet<CCDTierRecord>* ptrRecordSet = new (ELeave)CMDBRecordSet<CCDTierRecord>(KCDTIdTierRecord); |
|
723 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
724 } |
|
725 else |
|
726 { |
|
727 CCDTierRecord* ptrNewRecord = (CCDTierRecord*)CCDRecordBase::RecordFactoryL(KCDTIdTierRecord); |
|
728 InitAndAddL(ptrNewRecord,aRecordId); |
|
729 } |
|
730 break; |
|
731 |
|
732 case KCDTIdMCprRecord: |
|
733 if(aType != EInsert) |
|
734 { |
|
735 CMDBRecordSet<CCDMCprRecord>* ptrRecordSet = new (ELeave)CMDBRecordSet<CCDMCprRecord>(KCDTIdMCprRecord); |
|
736 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
737 } |
|
738 else |
|
739 { |
|
740 CCDMCprRecord* ptrNewRecord = (CCDMCprRecord*)CCDRecordBase::RecordFactoryL(KCDTIdMCprRecord); |
|
741 InitAndAddL(ptrNewRecord,aRecordId); |
|
742 } |
|
743 break; |
|
744 |
|
745 case KCDTIdCprRecord: |
|
746 if(aType != EInsert) |
|
747 { |
|
748 CMDBRecordSet<CCDCprRecord>* ptrRecordSet = new (ELeave)CMDBRecordSet<CCDCprRecord>(KCDTIdCprRecord); |
|
749 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
750 } |
|
751 else |
|
752 { |
|
753 CCDCprRecord* ptrNewRecord = (CCDCprRecord*)CCDRecordBase::RecordFactoryL(KCDTIdCprRecord); |
|
754 InitAndAddL(ptrNewRecord,aRecordId); |
|
755 } |
|
756 break; |
|
757 |
|
758 case KCDTIdSCprRecord: |
|
759 if(aType != EInsert) |
|
760 { |
|
761 CMDBRecordSet<CCDSCprRecord>* ptrRecordSet = new (ELeave)CMDBRecordSet<CCDSCprRecord>(KCDTIdSCprRecord); |
|
762 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
763 } |
|
764 else |
|
765 { |
|
766 CCDSCprRecord* ptrNewRecord = (CCDSCprRecord*)CCDRecordBase::RecordFactoryL(KCDTIdSCprRecord); |
|
767 InitAndAddL(ptrNewRecord,aRecordId); |
|
768 } |
|
769 break; |
|
770 |
|
771 case KCDTIdProtocolRecord: |
|
772 if(aType != EInsert) |
|
773 { |
|
774 CMDBRecordSet<CCDProtocolRecord>* ptrRecordSet = new (ELeave)CMDBRecordSet<CCDProtocolRecord>(KCDTIdProtocolRecord); |
|
775 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
776 } |
|
777 else |
|
778 { |
|
779 CCDProtocolRecord* ptrNewRecord = (CCDProtocolRecord*)CCDRecordBase::RecordFactoryL(KCDTIdProtocolRecord); |
|
780 InitAndAddL(ptrNewRecord,aRecordId); |
|
781 } |
|
782 break; |
|
783 |
|
784 case KCDTIdBearerTypeRecord: |
|
785 if(aType != EInsert) |
|
786 { |
|
787 CMDBRecordSet<CCDBearerTypeRecord>* ptrRecordSet = new (ELeave)CMDBRecordSet<CCDBearerTypeRecord>(KCDTIdBearerTypeRecord); |
|
788 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
789 } |
|
790 else |
|
791 { |
|
792 CCDBearerTypeRecord* ptrNewRecord = static_cast<CCDBearerTypeRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdBearerTypeRecord)); |
|
793 InitAndAddL(ptrNewRecord,aRecordId); |
|
794 } |
|
795 break; |
|
796 #endif // SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY |
|
797 case KCDTIdIapPrioritySelectionPolicyRecord: |
|
798 if(aType != EInsert) |
|
799 { |
|
800 CMDBRecordSet<CCDIAPPrioritySelectionPolicyRecord>* ptrRecordSet = new (ELeave)CMDBRecordSet<CCDIAPPrioritySelectionPolicyRecord>(KCDTIdIapPrioritySelectionPolicyRecord); |
|
801 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
802 } |
|
803 else |
|
804 { |
|
805 CCDIAPPrioritySelectionPolicyRecord* ptrNewRecord = (CCDIAPPrioritySelectionPolicyRecord*)CCDRecordBase::RecordFactoryL(KCDTIdIapPrioritySelectionPolicyRecord); |
|
806 InitAndAddL(ptrNewRecord,aRecordId); |
|
807 } |
|
808 break; |
|
809 |
|
810 case KCDTIdEAPSecRecord: |
|
811 if(aType != EInsert) |
|
812 { |
|
813 CMDBRecordSet<CCDEAPSecRecord>* ptrRecordSet = new (ELeave)CMDBRecordSet<CCDEAPSecRecord>(KCDTIdEAPSecRecord); |
|
814 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
815 } |
|
816 else |
|
817 { |
|
818 CCDEAPSecRecord* ptrNewRecord = (CCDEAPSecRecord*)CCDRecordBase::RecordFactoryL(KCDTIdEAPSecRecord); |
|
819 InitAndAddL(ptrNewRecord,aRecordId); |
|
820 } |
|
821 break; |
|
822 |
|
823 case KCDTIdTunEAPRecord: |
|
824 if(aType != EInsert) |
|
825 { |
|
826 CMDBRecordSet<CCDTunEAPRecord>* ptrRecordSet = new (ELeave)CMDBRecordSet<CCDTunEAPRecord>(KCDTIdTunEAPRecord); |
|
827 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
828 } |
|
829 else |
|
830 { |
|
831 CCDTunEAPRecord* ptrNewRecord = (CCDTunEAPRecord*)CCDRecordBase::RecordFactoryL(KCDTIdTunEAPRecord); |
|
832 InitAndAddL(ptrNewRecord,aRecordId); |
|
833 } |
|
834 break; |
|
835 |
|
836 case KCDTIdEAPTLSRecord: |
|
837 if(aType != EInsert) |
|
838 { |
|
839 CMDBRecordSet<CCDEAPTLSRecord>* ptrRecordSet = new (ELeave)CMDBRecordSet<CCDEAPTLSRecord>(KCDTIdEAPTLSRecord); |
|
840 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
841 } |
|
842 else |
|
843 { |
|
844 CCDEAPTLSRecord* ptrNewRecord = (CCDEAPTLSRecord*)CCDRecordBase::RecordFactoryL(KCDTIdEAPTLSRecord); |
|
845 InitAndAddL(ptrNewRecord,aRecordId); |
|
846 } |
|
847 break; |
|
848 |
|
849 case KCDTIdLEAPRecord: |
|
850 if(aType != EInsert) |
|
851 { |
|
852 CMDBRecordSet<CCDLEAPRecord>* ptrRecordSet = new (ELeave)CMDBRecordSet<CCDLEAPRecord>(KCDTIdLEAPRecord); |
|
853 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
854 } |
|
855 else |
|
856 { |
|
857 CCDLEAPRecord* ptrNewRecord = (CCDLEAPRecord*)CCDRecordBase::RecordFactoryL(KCDTIdLEAPRecord); |
|
858 InitAndAddL(ptrNewRecord,aRecordId); |
|
859 } |
|
860 break; |
|
861 |
|
862 case KCDTIdEapSimProtocolRecord: |
|
863 if(aType != EInsert) |
|
864 { |
|
865 CMDBRecordSet<CCDEapSimProtocolRecord>* ptrRecordSet = |
|
866 new(ELeave) CMDBRecordSet<CCDEapSimProtocolRecord>(KCDTIdEapSimProtocolRecord); |
|
867 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
868 } |
|
869 else |
|
870 { |
|
871 CCDEapSimProtocolRecord* ptrNewRecord = |
|
872 static_cast<CCDEapSimProtocolRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdEapSimProtocolRecord)); |
|
873 InitAndAddL(ptrNewRecord,aRecordId); |
|
874 } |
|
875 break; |
|
876 |
|
877 case KCDTIdEapAkaProtocolRecord: |
|
878 if(aType != EInsert) |
|
879 { |
|
880 CMDBRecordSet<CCDEapAkaProtocolRecord>* ptrRecordSet = |
|
881 new(ELeave) CMDBRecordSet<CCDEapAkaProtocolRecord>(KCDTIdEapAkaProtocolRecord); |
|
882 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
883 } |
|
884 else |
|
885 { |
|
886 CCDEapAkaProtocolRecord* ptrNewRecord = |
|
887 static_cast<CCDEapAkaProtocolRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdEapAkaProtocolRecord)); |
|
888 InitAndAddL(ptrNewRecord,aRecordId); |
|
889 } |
|
890 break; |
|
891 |
|
892 #ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY |
|
893 case KCDTIdPolicySelectorRecord: |
|
894 if(aType != EInsert) |
|
895 { |
|
896 CMDBRecordSet<CCDPolicySelectorRecord>* ptrRecordSet = |
|
897 new(ELeave) CMDBRecordSet<CCDPolicySelectorRecord>(KCDTIdPolicySelectorRecord); |
|
898 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
899 } |
|
900 else |
|
901 { |
|
902 CCDPolicySelectorRecord* ptrNewRecord = |
|
903 static_cast<CCDPolicySelectorRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdPolicySelectorRecord)); |
|
904 InitAndAddL(ptrNewRecord,aRecordId); |
|
905 } |
|
906 break; |
|
907 case KCDTIdPolicySelector2ParamsRecord: |
|
908 if(aType != EInsert) |
|
909 { |
|
910 CMDBRecordSet<CCDPolicySelector2ParamsRecord>* ptrRecordSet = |
|
911 new(ELeave) CMDBRecordSet<CCDPolicySelector2ParamsRecord>(KCDTIdPolicySelector2ParamsRecord); |
|
912 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
913 } |
|
914 else |
|
915 { |
|
916 CCDPolicySelector2ParamsRecord* ptrNewRecord = |
|
917 static_cast<CCDPolicySelector2ParamsRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdPolicySelector2ParamsRecord)); |
|
918 InitAndAddL(ptrNewRecord,aRecordId); |
|
919 } |
|
920 break; |
|
921 case KCDTIdGenericQosRecord: |
|
922 if(aType != EInsert) |
|
923 { |
|
924 CMDBRecordSet<CCDGenericQosRecord>* ptrRecordSet = |
|
925 new(ELeave) CMDBRecordSet<CCDGenericQosRecord>(KCDTIdGenericQosRecord); |
|
926 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
927 } |
|
928 else |
|
929 { |
|
930 CCDGenericQosRecord* ptrNewRecord = |
|
931 static_cast<CCDGenericQosRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdGenericQosRecord)); |
|
932 InitAndAddL(ptrNewRecord,aRecordId); |
|
933 } |
|
934 break; |
|
935 case KCDTIdWifiScanEngineRecord: |
|
936 if(aType != EInsert) |
|
937 { |
|
938 CMDBRecordSet<CCDWifiScanEngineRecord>* ptrRecordSet = |
|
939 new(ELeave) CMDBRecordSet<CCDWifiScanEngineRecord>(KCDTIdWifiScanEngineRecord); |
|
940 SaveTableProtection((CMDBRecordSetBase*)ptrRecordSet); |
|
941 } |
|
942 else |
|
943 { |
|
944 CCDWifiScanEngineRecord* ptrNewRecord = |
|
945 static_cast<CCDWifiScanEngineRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdWifiScanEngineRecord)); |
|
946 InitAndAddL(ptrNewRecord,aRecordId); |
|
947 } |
|
948 break; |
|
949 #endif //SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY |
|
950 default: |
|
951 User::Leave(KErrArgument); |
|
952 break; |
|
953 }; |
|
954 |
|
955 } |
|
956 |
|
957 void DBAccess::RemoveRecord(TInt aPos) |
|
958 { |
|
959 CMDBRecordBase* recordToRemove = iTable->iRecords[aPos]; |
|
960 iTable->iRecords.Remove(aPos); |
|
961 |
|
962 delete recordToRemove; |
|
963 } |
|
964 |
|
965 TBool DBAccess::ConvertLinkRecords(CMDBElement* aPtrField, TPtrC& aColumn,TPtrC& aSetting,TMDBAttributeFlags aAttribute) |
|
966 { |
|
967 TBool err(EFalse); |
|
968 |
|
969 switch(iTableId) |
|
970 { |
|
971 case KCDTIdIAPRecord: |
|
972 err = SetLinkedRecord(ELRIAP, aPtrField,aColumn,aSetting,aAttribute); |
|
973 break; |
|
974 case KCDTIdAccessPointRecord: |
|
975 err = SetLinkedRecord(ELRAccessPoints, aPtrField,aColumn,aSetting,aAttribute); |
|
976 break; |
|
977 case KCDTIdWLANServiceExtRecord: |
|
978 err = SetLinkedRecord(ELRWLANServiceExt, aPtrField,aColumn,aSetting,aAttribute); |
|
979 break; |
|
980 case KCDTIdEAPSecRecord: |
|
981 err = SetLinkedRecord(ELREAPSec, aPtrField,aColumn,aSetting,aAttribute); |
|
982 break; |
|
983 case KCDTIdTunEAPRecord: |
|
984 err = SetLinkedRecord(ELRTunEapSettings, aPtrField,aColumn,aSetting,aAttribute); |
|
985 break; |
|
986 /** |
|
987 * in the case of xml processing the LocationForDataAndFax, LocationForPhoneServicesAndSMS, |
|
988 * DefaultNetwork records in the ConnectionPref table are a links |
|
989 */ |
|
990 case KCDTIdGlobalSettingsRecord: |
|
991 err = SetLinkedRecord(ELRGlobalSettings, aPtrField,aColumn,aSetting,aAttribute); |
|
992 break; |
|
993 /** |
|
994 * in the case of xml processing the IAP record in the ConnectionPref table is a link |
|
995 */ |
|
996 case KCDTIdConnectionPrefsRecord: |
|
997 err = SetLinkedRecord(ELRConnectionPreference, aPtrField,aColumn,aSetting,aAttribute); |
|
998 break; |
|
999 case KCDTIdWAPIPBearerRecord: |
|
1000 err = SetLinkedRecord(ELRWAPIPBearer, aPtrField,aColumn,aSetting,aAttribute); |
|
1001 break; |
|
1002 #ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY |
|
1003 case KCDTIdBearerTypeRecord: |
|
1004 err = SetLinkedRecord(ELRBearerType, aPtrField,aColumn,aSetting,aAttribute); |
|
1005 break; |
|
1006 case KCDTIdApPrioritySelectionPolicyRecord: |
|
1007 err = SetLinkedRecord(ELRAPPrioritySel, aPtrField,aColumn,aSetting,aAttribute); |
|
1008 break; |
|
1009 case KCDTIdTierRecord: |
|
1010 err = SetLinkedRecord(ELRTier, aPtrField,aColumn,aSetting,aAttribute); |
|
1011 break; |
|
1012 #endif //SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY |
|
1013 default: ; |
|
1014 } |
|
1015 |
|
1016 return err; |
|
1017 } |
|
1018 /* This is a special case here because in the cfg files there can be legacy links. |
|
1019 * Legacy link menas that there is a table name in the given record and another field |
|
1020 * which is the record is of the referenced record. For example Bearer and BearerType |
|
1021 * in the IAP record. |
|
1022 * The trick here is that we should check particular text fields, which basically can |
|
1023 * contain anything, but in this case only specific values, the known table names, can |
|
1024 * be in the field value.*/ |
|
1025 TBool DBAccess::CheckLegacyLinkRecords(TPtrC& aColumn,TPtrC& aSetting) |
|
1026 { |
|
1027 TInt i = 0; |
|
1028 TPtrC actField = LegacyLinkFields[i]; |
|
1029 while (actField.Compare(aColumn) != 0 && |
|
1030 actField.Compare(TPtrC(NO_MORE_RECORDS)) != 0) |
|
1031 { |
|
1032 actField.Set(TPtrC(LegacyLinkFields[++i])); |
|
1033 } |
|
1034 |
|
1035 if (actField.Compare(TPtrC(NO_MORE_RECORDS)) != 0) |
|
1036 { |
|
1037 //we've found a legacy link, where the table name is set. Check whether |
|
1038 //the given table name is valid -> known by CED |
|
1039 i = 0; |
|
1040 TPtrC actTableName = tableArray[i]; |
|
1041 while (actTableName.Compare(aSetting) != 0 && |
|
1042 actTableName.Compare(TPtrC(NO_MORE_RECORDS)) != 0) |
|
1043 { |
|
1044 actTableName.Set(TPtrC(tableArray[++i])); |
|
1045 } |
|
1046 |
|
1047 if (actTableName.Compare(TPtrC(NO_MORE_RECORDS)) != 0) |
|
1048 { |
|
1049 //we got the referenced table as known table |
|
1050 return KErrNone; |
|
1051 } |
|
1052 else |
|
1053 { |
|
1054 //we don't get the referenced table -> CED doesn't know this tablename |
|
1055 return KErrNotFound; |
|
1056 } |
|
1057 } |
|
1058 return KErrNone; |
|
1059 } |
|
1060 |
|
1061 TBool DBAccess::ConvertEnumsL(CMDBElement* aPtrField, TPtrC& aColumn,TPtrC& aSetting,TMDBAttributeFlags aAttribute) |
|
1062 { |
|
1063 |
|
1064 if(ConvertMiscEnums(aPtrField,aColumn,aSetting,aAttribute)) |
|
1065 { |
|
1066 return ETrue; |
|
1067 } |
|
1068 TBool result(EFalse); |
|
1069 switch(iTableId) |
|
1070 { |
|
1071 case KCDTIdConnectionPrefsRecord: |
|
1072 result = ConvertConnectionPrefEnums(aPtrField,aColumn,aSetting,aAttribute); |
|
1073 break; |
|
1074 case KCDTIdDialInISPRecord: |
|
1075 case KCDTIdDialOutISPRecord: |
|
1076 result = ConvertISPEnums(aPtrField,aColumn,aSetting,aAttribute); |
|
1077 break; |
|
1078 case KCDTIdModemBearerRecord: |
|
1079 case KCDTIdLANBearerRecord: |
|
1080 case KCDTIdVirtualBearerRecord: |
|
1081 result = ConvertModemEnums(aPtrField,aColumn,aSetting,aAttribute); |
|
1082 break; |
|
1083 case KCDTIdWAPSMSBearerRecord: |
|
1084 case KCDTIdWAPIPBearerRecord: |
|
1085 result = ConvertWAPEnums(aPtrField,aColumn,aSetting,aAttribute); |
|
1086 break; |
|
1087 case KCDTIdPANServiceExtRecord: |
|
1088 result = ConvertPANEnums(aPtrField,aColumn,aSetting,aAttribute); |
|
1089 break; |
|
1090 case KCDTIdIapPrioritySelectionPolicyRecord: |
|
1091 result = ConvertIapPrioritySelectionPolicyEnums(aPtrField,aColumn,aSetting,aAttribute); |
|
1092 break; |
|
1093 #ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY |
|
1094 case KCDTIdApPrioritySelectionPolicyRecord: |
|
1095 result = ConvertApPrioritySelectionPolicyEnums(aPtrField,aColumn,aSetting,aAttribute); |
|
1096 break; |
|
1097 #endif // SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY |
|
1098 |
|
1099 case KCDTIdEAPSecRecord: |
|
1100 result = ConvertEAPSecEnums(aPtrField,aColumn,aSetting,aAttribute); |
|
1101 break; |
|
1102 case KCDTIdTunEAPRecord: |
|
1103 result = ConvertTUNEAPSecEnums(aPtrField,aColumn,aSetting,aAttribute); |
|
1104 break; |
|
1105 case KCDTIdGlobalSettingsRecord: |
|
1106 case KCDTIdWLANServiceExtRecord: |
|
1107 result = ConvertWLANEnums(aPtrField,aColumn,aSetting,aAttribute); |
|
1108 break; |
|
1109 case KCDTIdOutgoingGprsRecord: |
|
1110 case KCDTIdIncomingGprsRecord: |
|
1111 result = ConvertGPRSEnums(aPtrField,aColumn,aSetting,aAttribute); |
|
1112 break; |
|
1113 |
|
1114 default: |
|
1115 return EFalse; |
|
1116 } |
|
1117 return result; |
|
1118 } |
|
1119 |
|
1120 |
|
1121 |
|
1122 TInt DBAccess::ConvertSpecialCharsL(TInt aTempType,CMDBElement* aPtrField,TPtrC& aColumn,TPtrC& aSetting,TMDBAttributeFlags aAttribute) |
|
1123 { |
|
1124 const TInt E_NOERROR = -1; // not added to global list to avoid its use in wider contexts, eg error code lookup |
|
1125 TInt errorReason = E_NOERROR; |
|
1126 TInt i = 0; |
|
1127 TBuf<MAX_COL_LONG_VAL_LEN> TempValue; |
|
1128 |
|
1129 gMsg->Dbg(_L("Special char precess Input Column: [%S] , Value:[%S] "),&aColumn,&aSetting); |
|
1130 while(errorReason == E_NOERROR && i < aSetting.Length()) |
|
1131 { |
|
1132 TUint16 settingChar = aSetting[i++]; |
|
1133 if(settingChar == '\\') |
|
1134 { |
|
1135 if(i < aSetting.Length()) |
|
1136 { |
|
1137 settingChar = aSetting[i++]; |
|
1138 switch(settingChar) |
|
1139 { |
|
1140 case 't': // Emit a tab |
|
1141 settingChar = '\t'; |
|
1142 break; |
|
1143 case 'n': // Emit a LF |
|
1144 settingChar = '\n'; |
|
1145 break; |
|
1146 case '[': // Emit a [ |
|
1147 break; |
|
1148 case ']': // Emit a ] |
|
1149 break; |
|
1150 case '\\': // Emit a backslash |
|
1151 break; |
|
1152 case 'x': // Emit hex-coded char |
|
1153 if(i + 4 <= aSetting.Length()) |
|
1154 { |
|
1155 TPtrC hexStr(aSetting.Mid(i, 4)); |
|
1156 TLex hexLex(hexStr); |
|
1157 if(hexLex.Val(settingChar, EHex) != KErrNone) |
|
1158 { |
|
1159 errorReason = E_BADHEXADECIMAL; |
|
1160 } |
|
1161 i += 4; |
|
1162 } |
|
1163 else |
|
1164 { |
|
1165 errorReason = E_BADHEXADECIMAL; |
|
1166 } |
|
1167 break; |
|
1168 default: |
|
1169 errorReason = E_BADESCAPEDCHAR; |
|
1170 break; |
|
1171 } |
|
1172 } |
|
1173 else |
|
1174 { |
|
1175 errorReason = E_BADESCAPEDCHAR; |
|
1176 } |
|
1177 } |
|
1178 TempValue.Append(settingChar); |
|
1179 } |
|
1180 |
|
1181 TPtrC NewSetting; |
|
1182 NewSetting.Set(TempValue); |
|
1183 |
|
1184 if(errorReason != E_NOERROR) |
|
1185 { |
|
1186 gMsg->Msg(_L("ERR: Special char processing of %S failed due to %S"), &aColumn, &errorCode[errorReason]); |
|
1187 return KErrArgument; |
|
1188 } |
|
1189 |
|
1190 AssignFieldValuesL(aColumn,aTempType,aPtrField,NewSetting,aAttribute); |
|
1191 |
|
1192 return KErrNone; |
|
1193 } |
|
1194 |
|
1195 |
|
1196 TBool DBAccess::AssignFieldValuesL(TPtrC& aColumn,TInt aTempType,CMDBElement* aPtrField,TPtrC& aSetting,TMDBAttributeFlags /*aAttribute*/) |
|
1197 { |
|
1198 TBool valueIsValid=ETrue; |
|
1199 |
|
1200 switch(aTempType) |
|
1201 { |
|
1202 case EText: |
|
1203 { |
|
1204 CMDBTextFieldBase* ptrTempField = (CMDBTextFieldBase*)aPtrField; |
|
1205 if(aSetting.Length() > (MAX_COL_VAL_LEN - 1)) |
|
1206 { |
|
1207 //truncate truncate |
|
1208 ptrTempField->SetMaxLengthL(MAX_COL_VAL_LEN - 1); |
|
1209 *ptrTempField = aSetting.Mid(0,MAX_COL_VAL_LEN - 1); |
|
1210 } |
|
1211 else |
|
1212 { |
|
1213 ptrTempField->SetMaxLengthL(aSetting.Length()); |
|
1214 *ptrTempField = aSetting; |
|
1215 } |
|
1216 |
|
1217 // (*ptrTempField).SetAttributes(aAttribute); |
|
1218 TBuf<MAX_COL_VAL_LEN> pColumnV; |
|
1219 pColumnV = *((CMDBField<TDesC>*)ptrTempField); |
|
1220 gMsg->Msg(_L(" Column [%S] set to [%S]"), &aColumn, &pColumnV); |
|
1221 } |
|
1222 break; |
|
1223 case EDesC8: |
|
1224 { |
|
1225 CMDBBinFieldBase* ptrTempField = (CMDBBinFieldBase*)aPtrField; |
|
1226 TBuf8<MAX_COL_VAL_LEN> pColumnV; |
|
1227 TBuf<MAX_COL_VAL_LEN> pColumnVUni; |
|
1228 if(aSetting.Length() > (MAX_COL_VAL_LEN - 1)) |
|
1229 { |
|
1230 pColumnV.Mid(0, MAX_COL_VAL_LEN - 1); |
|
1231 } |
|
1232 else |
|
1233 { |
|
1234 pColumnV.Copy(aSetting ); |
|
1235 } |
|
1236 |
|
1237 ptrTempField->SetMaxLengthL(pColumnV.Length()); |
|
1238 *ptrTempField = pColumnV; |
|
1239 |
|
1240 pColumnVUni.Copy(pColumnV); |
|
1241 gMsg->Msg(_L(" Column [%S] set to [%S]"), &aColumn, &pColumnVUni); |
|
1242 } |
|
1243 break; |
|
1244 case EBool: |
|
1245 { |
|
1246 CMDBField<TBool>* ptrTempField = (CMDBField<TBool>*)aPtrField; |
|
1247 TBool valueToSet=ETrue; |
|
1248 |
|
1249 // check value isn't TRUE enum |
|
1250 if (aSetting.Compare(TPtrC(TRUE_VAL)) == 0) |
|
1251 { |
|
1252 gMsg->Dbg(_L(" The Value is set to ETrue")); |
|
1253 valueToSet = ETrue; |
|
1254 } |
|
1255 else if (aSetting.Compare(TPtrC(FALSE_VAL)) == 0) |
|
1256 { |
|
1257 gMsg->Dbg(_L(" The Value is set to EFalse")); |
|
1258 valueToSet = EFalse; |
|
1259 } |
|
1260 else |
|
1261 { |
|
1262 gMsg->Msg(_L(" ERR: Boolean mismatch column [%S] value [%S] - will not populate field."), &aColumn, &aSetting); |
|
1263 valueIsValid=EFalse; |
|
1264 if (iValidityChecking) User::Leave(KErrArgument); |
|
1265 } |
|
1266 |
|
1267 if(valueIsValid) |
|
1268 { |
|
1269 *ptrTempField = valueToSet; |
|
1270 gMsg->Msg(_L(" Column [%S] set to [%d]"), &aColumn, (TBool)*ptrTempField); |
|
1271 } |
|
1272 } |
|
1273 break; |
|
1274 |
|
1275 |
|
1276 case EInt: |
|
1277 { |
|
1278 CMDBField<TInt>* ptrTempField = (CMDBField<TInt>*)aPtrField; |
|
1279 TInt32 valueToSet; |
|
1280 TBool isHex = (aSetting.FindF(KHexMarker) == 0); |
|
1281 |
|
1282 if (isHex) |
|
1283 { |
|
1284 TUint32 hexVal; |
|
1285 TLex lex(aSetting.Mid(KHexMarker().Length())); |
|
1286 TInt err = lex.Val(hexVal, EHex); |
|
1287 if(err != KErrNone) |
|
1288 { |
|
1289 gMsg->Msg(_L("ERR: Corrupt hex value '%S' - will not populate field."), &aSetting); |
|
1290 if (iValidityChecking) User::Leave(KErrArgument); |
|
1291 valueIsValid=EFalse; |
|
1292 } |
|
1293 else |
|
1294 { |
|
1295 valueToSet = hexVal; |
|
1296 } |
|
1297 } |
|
1298 else |
|
1299 { |
|
1300 TLex lex(aSetting); |
|
1301 TInt err = lex.Val(valueToSet); |
|
1302 if(err != KErrNone) |
|
1303 { |
|
1304 gMsg->Msg(_L("ERR: Integer mismatch column [%S] value [%S] - will not populate field."), &aColumn, &aSetting); |
|
1305 if (iValidityChecking) User::Leave(KErrArgument); |
|
1306 valueIsValid=EFalse; |
|
1307 } |
|
1308 } |
|
1309 |
|
1310 if(valueIsValid) |
|
1311 { |
|
1312 *ptrTempField = valueToSet; |
|
1313 gMsg->Msg(_L(" Column [%S] set to [%d]"), &aColumn, valueToSet); |
|
1314 } |
|
1315 } |
|
1316 break; |
|
1317 case EUint32: |
|
1318 { |
|
1319 CMDBField<TUint32>* ptrTempField = (CMDBField<TUint32>*)aPtrField; |
|
1320 TUint32 valueToSet; |
|
1321 TBool isHex = (aSetting.FindF(KHexMarker) == 0); |
|
1322 TBool valueIsValid=ETrue; |
|
1323 |
|
1324 if (isHex) |
|
1325 { |
|
1326 TLex lex(aSetting.Mid(KHexMarker().Length())); |
|
1327 TInt err = lex.Val(valueToSet, EHex); |
|
1328 if(err != KErrNone) |
|
1329 { |
|
1330 gMsg->Msg(_L("ERR: Corrupt hex value '%S' - will not populate field."), &aSetting); |
|
1331 if (iValidityChecking) User::Leave(KErrArgument); |
|
1332 valueIsValid=EFalse; |
|
1333 } |
|
1334 } |
|
1335 else |
|
1336 { |
|
1337 TLex lex(aSetting); |
|
1338 TInt err = lex.Val(valueToSet,EDecimal); |
|
1339 if(err != KErrNone) |
|
1340 { |
|
1341 gMsg->Msg(_L("ERR: UInt32 mismatch column [%S] value [%S] - will not populate field."), &aColumn, &aSetting); |
|
1342 if (iValidityChecking) User::Leave(KErrArgument); |
|
1343 valueIsValid=EFalse; |
|
1344 } |
|
1345 } |
|
1346 |
|
1347 if(valueIsValid) |
|
1348 { |
|
1349 *ptrTempField = valueToSet; |
|
1350 gMsg->Msg(_L(" Column [%S] set to [%d]"), &aColumn, valueToSet); |
|
1351 } |
|
1352 } |
|
1353 break; |
|
1354 |
|
1355 case EMedText: |
|
1356 { |
|
1357 CMDBTextFieldBase* ptrTempField = (CMDBTextFieldBase*)aPtrField; |
|
1358 |
|
1359 if(aSetting.Length() > (MAX_COL_MED_VAL_LEN - 1)) |
|
1360 { |
|
1361 //truncate truncate |
|
1362 ptrTempField->SetMaxLengthL(MAX_COL_MED_VAL_LEN - 1); |
|
1363 *ptrTempField = aSetting.Mid(0,MAX_COL_MED_VAL_LEN - 1); |
|
1364 } |
|
1365 else |
|
1366 { |
|
1367 ptrTempField->SetMaxLengthL(aSetting.Length()); |
|
1368 *ptrTempField = aSetting; |
|
1369 } |
|
1370 //(*ptrTempField).SetAttributes(aAttribute); |
|
1371 |
|
1372 TBuf<MAX_COL_MED_VAL_LEN> pColumnV; |
|
1373 pColumnV = *((CMDBField<TDesC>*)ptrTempField); |
|
1374 gMsg->Msg(_L(" Column [%S] set to [%S]"), &aColumn, &pColumnV); |
|
1375 } |
|
1376 break; |
|
1377 case ELongText: |
|
1378 { |
|
1379 CMDBTextFieldBase* ptrTempField = (CMDBTextFieldBase*)aPtrField; |
|
1380 if(aSetting.Length() > (MAX_COL_LONG_VAL_LEN - 1)) |
|
1381 { |
|
1382 //truncate truncate |
|
1383 ptrTempField->SetMaxLengthL(MAX_COL_LONG_VAL_LEN - 1); |
|
1384 *ptrTempField = aSetting.Mid(0,MAX_COL_LONG_VAL_LEN - 1); |
|
1385 } |
|
1386 else |
|
1387 { |
|
1388 ptrTempField->SetMaxLengthL(aSetting.Length()); |
|
1389 *ptrTempField = aSetting; |
|
1390 } |
|
1391 |
|
1392 //(*ptrTempField).SetAttributes(aAttribute); |
|
1393 |
|
1394 TBuf<MAX_COL_LONG_VAL_LEN> pColumnV; |
|
1395 pColumnV = *((CMDBField<TDesC>*)ptrTempField); |
|
1396 gMsg->Msg(_L(" Column [%S] set to [%S]"), &aColumn, &pColumnV); |
|
1397 } |
|
1398 break; |
|
1399 default: |
|
1400 User::Panic(_L("ERR: Field has unknown type: AssignFieldValuesL()"),KErrNotFound); |
|
1401 break; |
|
1402 } |
|
1403 |
|
1404 iColCount++; |
|
1405 |
|
1406 return valueIsValid; |
|
1407 } |
|
1408 |
|
1409 TInt DBAccess::SetColAndAttribL(TPtrC& aColumn,TPtrC& aSetting) |
|
1410 { |
|
1411 |
|
1412 TMDBAttributeFlags attribute = 0; |
|
1413 if(iSecure) |
|
1414 { |
|
1415 attribute = (iTable->iRecords[iTable->iRecords.Count()-1])->Attributes(); |
|
1416 if(aColumn.CompareC(KReadOnly) == 0 ) |
|
1417 { |
|
1418 if(aSetting == KTrueVal) |
|
1419 { |
|
1420 attribute |= ECDNoWriteButDelete; |
|
1421 } |
|
1422 else |
|
1423 { |
|
1424 attribute &= ~ECDNoWriteButDelete; |
|
1425 } |
|
1426 iColCount++; |
|
1427 (iTable->iRecords[iTable->iRecords.Count()-1])->SetAttributes(attribute); |
|
1428 return KErrNone; |
|
1429 } |
|
1430 |
|
1431 //you can't set hidden field in connpref |
|
1432 if(aColumn.CompareC(KHidden) == 0) |
|
1433 { |
|
1434 if(((iTable->iRecords[iTable->iRecords.Count()-1])->TypeId() & KCDMaskShowRecordType) != KCDTIdConnectionPrefsRecord) |
|
1435 { |
|
1436 if(aSetting == KTrueVal) |
|
1437 { |
|
1438 attribute |= ECDHidden; |
|
1439 } |
|
1440 else |
|
1441 { |
|
1442 attribute &= ECDHidden; |
|
1443 } |
|
1444 } |
|
1445 else |
|
1446 { |
|
1447 attribute &= ECDHidden; |
|
1448 } |
|
1449 iColCount++; |
|
1450 (iTable->iRecords[iTable->iRecords.Count()-1])->SetAttributes(attribute); |
|
1451 return KErrNone; |
|
1452 } |
|
1453 } |
|
1454 |
|
1455 |
|
1456 |
|
1457 |
|
1458 TInt tempType(0); |
|
1459 |
|
1460 gMsg->Dbg(_L(" Setting column [%S] value [%S]"), &aColumn, &aSetting); |
|
1461 |
|
1462 CMDBElement* ptrField = NULL; |
|
1463 |
|
1464 TRAPD(ret,(ptrField = (iTable->iRecords[iTable->iRecords.Count()-1])->GetFieldByNameL(aColumn,tempType))); |
|
1465 |
|
1466 if(ret != KErrNone) |
|
1467 { |
|
1468 gMsg->Dbg(_L(" ERR: GetFieldByNameL failed column [%S] value [%S] errorcode [%d]"), &aColumn, &aSetting, ret); |
|
1469 return ret; |
|
1470 } |
|
1471 |
|
1472 if((ptrField->ElementId() & KCDMaskShowFieldType) == KCDTIdRecordName) //good engineer writes code in hexadecimals ;) |
|
1473 { |
|
1474 iNameSet = ETrue; |
|
1475 } |
|
1476 |
|
1477 |
|
1478 if(ConvertEnumsL(ptrField,aColumn,aSetting,attribute)) |
|
1479 { |
|
1480 iColCount++; |
|
1481 return KErrNone; |
|
1482 } |
|
1483 |
|
1484 if(ConvertLinkRecords(ptrField,aColumn,aSetting,attribute)) |
|
1485 { |
|
1486 iColCount++; |
|
1487 return KErrNone; |
|
1488 } |
|
1489 |
|
1490 ret = CheckLegacyLinkRecords(aColumn,aSetting); |
|
1491 if (KErrNone != ret) |
|
1492 { |
|
1493 return ret; |
|
1494 } |
|
1495 |
|
1496 _LIT(KSpecialChar, "\\"); |
|
1497 |
|
1498 if(aSetting.Find(KSpecialChar) != KErrNotFound) |
|
1499 { |
|
1500 return ConvertSpecialCharsL(tempType,ptrField,aColumn,aSetting,attribute); |
|
1501 } |
|
1502 |
|
1503 ret = AssignFieldValuesL(aColumn,tempType,ptrField,aSetting,attribute); |
|
1504 |
|
1505 return ret?KErrNone:KErrNotFound; |
|
1506 } |
|
1507 |
|
1508 |
|
1509 // |
|
1510 //ENUM handlers// |
|
1511 // |
|
1512 |
|
1513 |
|
1514 |
|
1515 TBool DBAccess::ConvertConnectionPrefEnums(CMDBElement* aPtrField,TPtrC& aColumn,TPtrC& aSetting,TMDBAttributeFlags /*aAttribute*/) |
|
1516 { |
|
1517 |
|
1518 CMDBField<TUint32>* ptrTempField = (CMDBField<TUint32>*)aPtrField; |
|
1519 |
|
1520 TInt i(0); |
|
1521 TBuf<MAX_COL_NAME_LEN> column; |
|
1522 column = ENUM_ConnectionPrefArray[i]; |
|
1523 |
|
1524 if (aColumn.Compare(TPtrC(CONNECT_PREF_BEARER_SET)) == 0) |
|
1525 { |
|
1526 TLex lex(aSetting); |
|
1527 |
|
1528 // get the first token |
|
1529 TBool err = CheckBearer(aPtrField, lex.NextToken()); |
|
1530 if ( err ) |
|
1531 { |
|
1532 return EFalse; |
|
1533 } |
|
1534 |
|
1535 TPtrC token = lex.NextToken(); |
|
1536 |
|
1537 TBool exit = token.Length() > 0 && token.CompareF(_L("&")) == 0; |
|
1538 |
|
1539 while( exit ) |
|
1540 { |
|
1541 err = CheckBearer(aPtrField, lex.NextToken()); |
|
1542 |
|
1543 if( !err ) |
|
1544 { |
|
1545 TPtrC token = lex.NextToken(); |
|
1546 exit = token.Length() > 0 && token.CompareF(_L("&")) == 0; |
|
1547 } |
|
1548 else |
|
1549 { |
|
1550 return EFalse; |
|
1551 } |
|
1552 } |
|
1553 |
|
1554 TUint32 pColumnV; |
|
1555 pColumnV = *ptrTempField; |
|
1556 gMsg->Dbg(_L(" Column match in enumeration list")); |
|
1557 gMsg->Dbg(_L(" Column %S old value %S"), &aColumn, &aSetting); |
|
1558 gMsg->Dbg(_L(" Column %S new value %d"), &aColumn, pColumnV); |
|
1559 |
|
1560 gMsg->Msg(_L(" Column [%S] set to [%d]"), &aColumn, pColumnV); //todo remove |
|
1561 return ETrue; |
|
1562 } |
|
1563 else |
|
1564 { |
|
1565 while (column.Compare(TPtrC(NO_MORE_RECORDS)) != 0) |
|
1566 { |
|
1567 if (column.Compare(aColumn) == 0) |
|
1568 { |
|
1569 TInt j(0); |
|
1570 TBuf<MAX_COL_VAL_LEN> value; |
|
1571 value = ENUM_ConnectionPrefValueArray[i][j]; |
|
1572 while(value.Compare(TPtrC(NO_MORE_RECORDS))) |
|
1573 { |
|
1574 if (value.Compare(aSetting) == 0) |
|
1575 { |
|
1576 *ptrTempField = j; |
|
1577 |
|
1578 TUint32 pColumnV; |
|
1579 pColumnV = *ptrTempField; |
|
1580 gMsg->Dbg(_L(" Column match in enumeration list")); |
|
1581 gMsg->Dbg(_L(" Column %S old value %S"), &aColumn, &aSetting); |
|
1582 gMsg->Dbg(_L(" Column %S new value %d"), &column, pColumnV); |
|
1583 |
|
1584 gMsg->Msg(_L(" Column [%S] set to [%d]"), &aColumn, pColumnV); //todo remove |
|
1585 return ETrue; |
|
1586 } |
|
1587 j++; |
|
1588 value = ENUM_ConnectionPrefValueArray[i][j]; |
|
1589 } |
|
1590 } |
|
1591 column = ENUM_ConnectionPrefArray[++i]; |
|
1592 } |
|
1593 } |
|
1594 |
|
1595 return EFalse; |
|
1596 } |
|
1597 |
|
1598 TBool DBAccess::CheckBearer(CMDBElement* aPtrField,TPtrC aSetting) |
|
1599 { |
|
1600 TBool err(EFalse); |
|
1601 |
|
1602 CMDBField<TUint32>* ptrTempField = (CMDBField<TUint32>*)aPtrField; |
|
1603 |
|
1604 // Check for CONNECT_PREF_BEARER_SET enums |
|
1605 if (aSetting.CompareF(TPtrC(BEARER_SET_UNKNOWN)) == 0) |
|
1606 { |
|
1607 *ptrTempField = KCommDbBearerUnknown | *ptrTempField; |
|
1608 } |
|
1609 else if (aSetting.CompareF(TPtrC(BEARER_SET_CSD)) == 0) |
|
1610 { |
|
1611 *ptrTempField = KCommDbBearerCSD | *ptrTempField; |
|
1612 } |
|
1613 else if (aSetting.CompareF(TPtrC(BEARER_SET_WCDMA)) == 0) |
|
1614 { |
|
1615 *ptrTempField = KCommDbBearerWcdma | *ptrTempField; |
|
1616 } |
|
1617 else if (aSetting.CompareF(TPtrC(BEARER_SET_LAN)) == 0) |
|
1618 { |
|
1619 *ptrTempField = KCommDbBearerLAN | *ptrTempField; |
|
1620 } |
|
1621 else if (aSetting.CompareF(TPtrC(BEARER_SET_VIRTUAL)) == 0) |
|
1622 { |
|
1623 *ptrTempField = KCommDbBearerVirtual | *ptrTempField; |
|
1624 } |
|
1625 else if (aSetting.CompareF(TPtrC(BEARER_SET_PAN)) == 0) |
|
1626 { |
|
1627 *ptrTempField = KCommDbBearerPAN | *ptrTempField; |
|
1628 } |
|
1629 else if (aSetting.CompareF(TPtrC(BEARER_SET_WLAN)) == 0) |
|
1630 { |
|
1631 *ptrTempField = KCommDbBearerWLAN | *ptrTempField; |
|
1632 } |
|
1633 else if (aSetting.CompareF(TPtrC(BEARER_SET_PSD)) == 0) |
|
1634 { |
|
1635 *ptrTempField = KCommDbBearerPSD | *ptrTempField; |
|
1636 } |
|
1637 else |
|
1638 { |
|
1639 gMsg->Msg(_L("ERR: Token error [%S]"), &aSetting); |
|
1640 err = ETrue; |
|
1641 // default used because of BC |
|
1642 *ptrTempField = KCommDbBearerCSD | KCommDbBearerPSD; |
|
1643 } |
|
1644 |
|
1645 return err; |
|
1646 } |
|
1647 |
|
1648 TBool DBAccess::ConvertModemEnums(CMDBElement* aPtrField,TPtrC& aColumn,TPtrC& aSetting,TMDBAttributeFlags /*aAttribute*/) |
|
1649 { |
|
1650 |
|
1651 CMDBField<TUint32>* ptrTempField = (CMDBField<TUint32>*)aPtrField; |
|
1652 |
|
1653 if (aColumn.Compare(TPtrC(MODEM_RATE)) == 0) |
|
1654 { |
|
1655 // Check for Modem RATE enums |
|
1656 if (aSetting.Compare(TPtrC(MODEM_RATE_AUTO)) == 0) |
|
1657 { |
|
1658 *ptrTempField = (TUint32)EBpsAutobaud; |
|
1659 } |
|
1660 else if (aSetting.Compare(TPtrC(MODEM_RATE_SPECIAL)) == 0) |
|
1661 { |
|
1662 /* Note use of EBpsSpecial which has the value 0x80000000 |
|
1663 strictly 0x80000000 is not a valid value for a enum |
|
1664 as an enum is a int !. It would be better if EBpsSpecial was |
|
1665 defined as a different value */ |
|
1666 *ptrTempField = (TUint32)EBpsSpecial; |
|
1667 } |
|
1668 else |
|
1669 { |
|
1670 TBuf<MAX_COL_NAME_LEN> columnValue; |
|
1671 TUint32 i(0); |
|
1672 columnValue = ENUM_MODEM_RATEArray[i]; |
|
1673 while (columnValue.Compare(TPtrC(NO_MORE_RECORDS)) != 0) |
|
1674 { |
|
1675 if(aSetting.Compare(columnValue) == 0) |
|
1676 { |
|
1677 *ptrTempField = i; |
|
1678 break; |
|
1679 } |
|
1680 columnValue = ENUM_MODEM_RATEArray[++i]; |
|
1681 } |
|
1682 } |
|
1683 } |
|
1684 else if(aColumn.Compare(TPtrC(MODEM_FAX_CLASS_PREF)) == 0) |
|
1685 { |
|
1686 |
|
1687 // Check for MODEM_FAX_CLASS_PREF enums |
|
1688 if (aSetting.Compare(TPtrC(MODEM_FAX_AUTO)) == 0) |
|
1689 { |
|
1690 *ptrTempField = EClassAuto; |
|
1691 } |
|
1692 else if (aSetting.Compare(TPtrC(MODEM_FAX_1)) == 0) |
|
1693 { |
|
1694 *ptrTempField = EClass1; |
|
1695 } |
|
1696 else if (aSetting.Compare(TPtrC(MODEM_FAX_2)) == 0) |
|
1697 { |
|
1698 *ptrTempField = EClass2; |
|
1699 } |
|
1700 else if (aSetting.Compare(TPtrC(MODEM_FAX_2POINT0)) == 0) |
|
1701 { |
|
1702 *ptrTempField = EClass2point0; |
|
1703 } |
|
1704 else if (aSetting.Compare(TPtrC(MODEM_FAX_1POINT0)) == 0) |
|
1705 { |
|
1706 *ptrTempField = EClass1point0; |
|
1707 } |
|
1708 else |
|
1709 { |
|
1710 *ptrTempField = EClass2point1; |
|
1711 } |
|
1712 } |
|
1713 else |
|
1714 { |
|
1715 TInt i(0); |
|
1716 TBuf<MAX_COL_NAME_LEN> column; |
|
1717 column = ENUM_ModemBearerArray[i]; |
|
1718 |
|
1719 while (column.Compare(TPtrC(NO_MORE_RECORDS)) != 0) |
|
1720 { |
|
1721 if (column.Compare(aColumn) == 0) |
|
1722 { |
|
1723 TInt j(0); |
|
1724 TBuf<MAX_COL_VAL_LEN> value; |
|
1725 value = ENUM_ModemValueArray[i][j]; |
|
1726 while(value.Compare(TPtrC(NO_MORE_RECORDS))) |
|
1727 { |
|
1728 if (value.Compare(aSetting) == 0) |
|
1729 { |
|
1730 *ptrTempField = j; |
|
1731 |
|
1732 TUint32 pColumnV; |
|
1733 pColumnV = *ptrTempField; |
|
1734 gMsg->Dbg(_L(" Column match in enumeration list")); |
|
1735 gMsg->Dbg(_L(" Column %S old value %S"), &aColumn, &aSetting); |
|
1736 gMsg->Dbg(_L(" Column %S new value %d"), &column, j); |
|
1737 gMsg->Msg(_L(" Column [%S] set to [%d]"), &aColumn, pColumnV); //todo remove |
|
1738 return ETrue; |
|
1739 } |
|
1740 j++; |
|
1741 value = ENUM_ModemValueArray[i][j]; |
|
1742 } |
|
1743 } |
|
1744 column = ENUM_ModemBearerArray[++i]; |
|
1745 } |
|
1746 return EFalse; |
|
1747 } |
|
1748 |
|
1749 |
|
1750 TUint32 pColumnV; |
|
1751 pColumnV = *ptrTempField; |
|
1752 |
|
1753 gMsg->Dbg(_L(" Column match in enumeration list")); |
|
1754 gMsg->Dbg(_L(" Column %S old value %S"), &aColumn, &aSetting); |
|
1755 gMsg->Dbg(_L(" Column %S new value %d"), &aColumn, pColumnV); |
|
1756 |
|
1757 gMsg->Msg(_L(" Column [%S] set to [%d]"), &aColumn, pColumnV); //todo remove |
|
1758 return ETrue; |
|
1759 } |
|
1760 |
|
1761 TBool DBAccess::ConvertGPRSEnums(CMDBElement* aPtrField,TPtrC& aColumn,TPtrC& aSetting,TMDBAttributeFlags /*aAttribute*/) |
|
1762 { |
|
1763 CMDBField<TUint32>* ptrTempField = (CMDBField<TUint32>*)aPtrField; |
|
1764 |
|
1765 TBuf<MAX_COL_NAME_LEN> value; |
|
1766 TInt j(0); |
|
1767 |
|
1768 if (aColumn.Compare(TPtrC(GPRS_R5_DATA_COMPRESSION)) == 0) |
|
1769 { |
|
1770 value = ENUM_GPRS_R5_DATA_COMPRESSIONArray[j]; |
|
1771 while (value.Compare(TPtrC(NO_MORE_RECORDS)) != 0) |
|
1772 { |
|
1773 if (value.Compare(aSetting) == 0) |
|
1774 { |
|
1775 *ptrTempField = j; |
|
1776 TUint32 pColumnV; |
|
1777 pColumnV = *ptrTempField; |
|
1778 gMsg->Msg(_L(" Column [%S] set to [%d]"), &aColumn, pColumnV); |
|
1779 return ETrue; |
|
1780 } |
|
1781 value = ENUM_GPRS_R5_DATA_COMPRESSIONArray[++j]; |
|
1782 } |
|
1783 } |
|
1784 else if (aColumn.Compare(TPtrC(GPRS_R5_HEADER_COMPRESSION)) == 0) |
|
1785 { |
|
1786 value = ENUM_GPRS_R5_HEADER_COMPRESSIONArray[j]; |
|
1787 while (value.Compare(TPtrC(NO_MORE_RECORDS)) != 0) |
|
1788 { |
|
1789 if (value.Compare(aSetting) == 0) |
|
1790 { |
|
1791 *ptrTempField = j; |
|
1792 TUint32 pColumnV; |
|
1793 pColumnV = *ptrTempField; |
|
1794 gMsg->Msg(_L(" Column [%S] set to [%d]"), &aColumn, pColumnV); |
|
1795 return ETrue; |
|
1796 } |
|
1797 value = ENUM_GPRS_R5_HEADER_COMPRESSIONArray[++j]; |
|
1798 } |
|
1799 } |
|
1800 |
|
1801 else if (aColumn.Compare(TPtrC(GPRS_R4_PACKET_FLOW_IDENTIFIER)) == 0) |
|
1802 { |
|
1803 value = ENUM_GPRS_PACKET_FLOW_IDENTIFIERArray[j]; |
|
1804 while (value.Compare(TPtrC(NO_MORE_RECORDS)) != 0) |
|
1805 { |
|
1806 if (value.Compare(aSetting) == 0) |
|
1807 { |
|
1808 *ptrTempField = j; |
|
1809 TUint32 pColumnV; |
|
1810 pColumnV = *ptrTempField; |
|
1811 gMsg->Msg(_L(" Column [%S] set to [%d]"), &aColumn, pColumnV); |
|
1812 return ETrue; |
|
1813 } |
|
1814 value = ENUM_GPRS_PACKET_FLOW_IDENTIFIERArray[++j]; |
|
1815 } |
|
1816 } |
|
1817 |
|
1818 else if (aColumn.Compare(TPtrC(GPRS_UMTS_GPRS_RELEASE)) == 0) |
|
1819 { |
|
1820 value = ENUM_GPRS_UMTS_GPRS_RELEASEArray[j]; |
|
1821 while (value.Compare(TPtrC(NO_MORE_RECORDS)) != 0) |
|
1822 { |
|
1823 if (value.Compare(aSetting) == 0) |
|
1824 { |
|
1825 *ptrTempField = j; |
|
1826 TUint32 pColumnV; |
|
1827 pColumnV = *ptrTempField; |
|
1828 gMsg->Msg(_L(" Column [%S] set to [%d]"), &aColumn, pColumnV); |
|
1829 return ETrue; |
|
1830 } |
|
1831 value = ENUM_GPRS_UMTS_GPRS_RELEASEArray[++j]; |
|
1832 } |
|
1833 } |
|
1834 |
|
1835 return EFalse; |
|
1836 } |
|
1837 |
|
1838 TBool DBAccess::ConvertWAPEnums(CMDBElement* aPtrField,TPtrC& aColumn,TPtrC& aSetting,TMDBAttributeFlags /*aAttribute*/) |
|
1839 { |
|
1840 CMDBField<TUint32>* ptrTempField = (CMDBField<TUint32>*)aPtrField; |
|
1841 if (aColumn.Compare(TPtrC(WAP_WSP_OPTION)) == 0) |
|
1842 { |
|
1843 TBuf<MAX_COL_NAME_LEN> value; |
|
1844 TInt j(0); |
|
1845 value = ENUM_WAP_WSP_OPTIONArray[j]; |
|
1846 while (value.Compare(TPtrC(NO_MORE_RECORDS)) != 0) |
|
1847 { |
|
1848 if (value.Compare(aSetting) == 0) |
|
1849 { |
|
1850 *ptrTempField = j; |
|
1851 TUint32 pColumnV; |
|
1852 pColumnV = *ptrTempField; |
|
1853 gMsg->Msg(_L(" Column [%S] set to [%d]"), &aColumn, pColumnV); |
|
1854 return ETrue; |
|
1855 } |
|
1856 value = ENUM_WAP_WSP_OPTIONArray[++j]; |
|
1857 } |
|
1858 } |
|
1859 return EFalse; |
|
1860 } |
|
1861 |
|
1862 TBool DBAccess::ConvertISPEnums(CMDBElement* aPtrField,TPtrC& aColumn,TPtrC& aSetting,TMDBAttributeFlags /*aAttribute*/) |
|
1863 { |
|
1864 CMDBField<TUint32>* ptrTempField = (CMDBField<TUint32>*)aPtrField; |
|
1865 |
|
1866 if (aColumn.Compare(TPtrC(ISP_BEARER_NAME)) == 0) |
|
1867 { |
|
1868 // Check for IFCALLBACKTYPE enums |
|
1869 if (aSetting.Compare(TPtrC(BEARER_NAME_ASYNCHRONOUS)) == 0) |
|
1870 { |
|
1871 *ptrTempField = RMobileCall::KCapsDataCircuitAsynchronous; |
|
1872 } |
|
1873 else if (aSetting.Compare(TPtrC(BEARER_NAME_ASYNCHRONOUSRDI)) == 0) |
|
1874 { |
|
1875 *ptrTempField = RMobileCall::KCapsDataCircuitAsynchronousRDI; |
|
1876 } |
|
1877 else if (aSetting.Compare(TPtrC(BEARER_NAME_SYNCHRONOUS)) == 0) |
|
1878 { |
|
1879 *ptrTempField = RMobileCall::KCapsDataCircuitSynchronous; |
|
1880 } |
|
1881 else if (aSetting.Compare(TPtrC(BEARER_NAME_SYNCHRONOUSRDI)) == 0) |
|
1882 { |
|
1883 *ptrTempField = RMobileCall::KCapsDataCircuitSynchronousRDI; |
|
1884 } |
|
1885 else if (aSetting.Compare(TPtrC(BEARER_NAME_PADASYNCUDI)) == 0) |
|
1886 { |
|
1887 *ptrTempField = RMobileCall::KCapsPADAsyncUDI; |
|
1888 } |
|
1889 else if (aSetting.Compare(TPtrC(BEARER_NAME_PADASYNCRDI)) == 0) |
|
1890 { |
|
1891 *ptrTempField = RMobileCall::KCapsPADAsyncRDI; |
|
1892 } |
|
1893 else if (aSetting.Compare(TPtrC(BEARER_NAME_ACCESSSYNCUDI)) == 0) |
|
1894 { |
|
1895 *ptrTempField = RMobileCall::KCapsPacketAccessSyncUDI; |
|
1896 } |
|
1897 else if (aSetting.Compare(TPtrC(BEARER_NAME_ACCESSSYNCRDI)) == 0) |
|
1898 { |
|
1899 *ptrTempField = RMobileCall::KCapsPacketAccessSyncRDI; |
|
1900 } |
|
1901 else |
|
1902 { |
|
1903 *ptrTempField = (TUint32)RMobileCall::KCapsServiceExtended; |
|
1904 } |
|
1905 } |
|
1906 else if (aColumn.Compare(TPtrC(ISP_IF_CALLBACK_TYPE)) == 0) |
|
1907 { |
|
1908 // Check for IFCALLBACKTYPE enums |
|
1909 if (aSetting.Compare(TPtrC(MSCBCPCLIENTNUM)) == 0) |
|
1910 { |
|
1911 *ptrTempField = ECallbackActionMSCBCPRequireClientSpecifiedNumber; |
|
1912 } |
|
1913 else if (aSetting.Compare(TPtrC(MSCBCPSERVERNUM)) == 0) |
|
1914 { |
|
1915 *ptrTempField = ECallbackActionMSCBCPAcceptServerSpecifiedNumber; |
|
1916 } |
|
1917 else if (aSetting.Compare(TPtrC(MSCBCPOVERRIDESER)) == 0) |
|
1918 { |
|
1919 *ptrTempField = ECallbackActionMSCBCPOverrideServerSpecifiedNumber; |
|
1920 } |
|
1921 else |
|
1922 { |
|
1923 //todo Optimize or Cry! |
|
1924 TBuf<MAX_COL_NAME_LEN> columnValue; |
|
1925 TUint32 i(0); |
|
1926 columnValue = ENUM_ISP_IFCALLBACKTYPEArray[i]; |
|
1927 while (columnValue.Compare(TPtrC(NO_MORE_RECORDS)) != 0) |
|
1928 { |
|
1929 if(aSetting.Compare(columnValue) == 0) |
|
1930 { |
|
1931 *ptrTempField = i; |
|
1932 break; |
|
1933 } |
|
1934 columnValue = ENUM_ISP_IFCALLBACKTYPEArray[++i]; |
|
1935 } |
|
1936 } |
|
1937 } |
|
1938 else if (aColumn.Compare(TPtrC(ISP_BEARER_PROTOCOL)) == 0) |
|
1939 { |
|
1940 |
|
1941 // map the descriptor to an entry in RMobileCall::TMobileCallDataProtocol. |
|
1942 // Can't just use the index, as the first two entries both mean |
|
1943 // 'unspecified'. |
|
1944 const TDescEnumMap *pMap = IspBearerProtocolMap; |
|
1945 while((aSetting.Compare(TPtrC(pMap->OptionDescriptor)) != 0) && (pMap->EnumVal != RMobileCall::EProtocolUnspecified)) |
|
1946 { |
|
1947 ++pMap; |
|
1948 } |
|
1949 *ptrTempField = pMap->EnumVal; |
|
1950 } |
|
1951 else |
|
1952 { |
|
1953 TInt i(0); |
|
1954 TBuf<MAX_COL_NAME_LEN> column; |
|
1955 column = ENUM_ISPArray[i]; |
|
1956 |
|
1957 while (column.Compare(TPtrC(NO_MORE_RECORDS)) != 0) |
|
1958 { |
|
1959 if (column.Compare(aColumn) == 0) |
|
1960 { |
|
1961 TInt j(0); |
|
1962 TBuf<MAX_COL_VAL_LEN> value; |
|
1963 value = ENUM_ISPValueArray[i][j]; |
|
1964 while(value.Compare(TPtrC(NO_MORE_RECORDS))) |
|
1965 { |
|
1966 if (value.Compare(aSetting) == 0) |
|
1967 { |
|
1968 *ptrTempField = j; |
|
1969 |
|
1970 TUint32 pColumnV; |
|
1971 pColumnV = *ptrTempField; |
|
1972 gMsg->Msg(_L(" Column [%S] set to [%d]"), &aColumn, pColumnV); |
|
1973 return ETrue; |
|
1974 } |
|
1975 j++; |
|
1976 value = ENUM_ISPValueArray[i][j]; |
|
1977 } |
|
1978 } |
|
1979 column = ENUM_ISPArray[++i]; |
|
1980 } |
|
1981 return EFalse; |
|
1982 } |
|
1983 |
|
1984 TUint32 pColumnV; |
|
1985 pColumnV = *ptrTempField; |
|
1986 gMsg->Msg(_L(" Column [%S] set to [%d]"), &aColumn, pColumnV); |
|
1987 |
|
1988 return ETrue; |
|
1989 } |
|
1990 |
|
1991 |
|
1992 TBool DBAccess::ConvertMiscEnums(CMDBElement* aPtrField, TPtrC& aColumn,TPtrC& aSetting,TMDBAttributeFlags /*aAttribute*/) |
|
1993 { |
|
1994 CMDBField<TUint32>* ptrTempField = (CMDBField<TUint32>*)aPtrField; |
|
1995 |
|
1996 TInt i(0); |
|
1997 TBuf<MAX_COL_NAME_LEN> column; |
|
1998 column = ENUM_MiscArray[i]; |
|
1999 |
|
2000 |
|
2001 |
|
2002 //General Enums |
|
2003 while (column.Compare(TPtrC(NO_MORE_RECORDS)) != 0) |
|
2004 { |
|
2005 if (column.Compare(aColumn) == 0) |
|
2006 { |
|
2007 TInt j(0); |
|
2008 TBuf<MAX_COL_VAL_LEN> value; |
|
2009 value = ENUM_MiscValueArray[i][j]; |
|
2010 while(value.Compare(TPtrC(NO_MORE_RECORDS))) |
|
2011 { |
|
2012 if (value.Compare(aSetting) == 0) |
|
2013 { |
|
2014 *ptrTempField = j; |
|
2015 |
|
2016 TUint32 pColumnV; |
|
2017 pColumnV = *ptrTempField; |
|
2018 gMsg->Dbg(_L(" Column match in enumeration list")); |
|
2019 gMsg->Dbg(_L(" Column %S old value %S"), &aColumn, &aSetting); |
|
2020 gMsg->Dbg(_L(" Column %S new value %d"), &column, pColumnV); |
|
2021 |
|
2022 gMsg->Msg(_L(" Column [%S] set to [%d]"), &aColumn, pColumnV); //todo remove |
|
2023 return ETrue; |
|
2024 } |
|
2025 j++; |
|
2026 value = ENUM_MiscValueArray[i][j]; |
|
2027 } |
|
2028 } |
|
2029 column = ENUM_MiscArray[++i]; |
|
2030 } |
|
2031 |
|
2032 |
|
2033 //Bearer Type Enums in Bearer tables |
|
2034 if (aColumn.CompareF(TPtrC(BEARER_TECHNOLOGY)) == 0) |
|
2035 { |
|
2036 gMsg->Dbg(_L(" Column match in enumeration list")); |
|
2037 if (aSetting.CompareF(TPtrC(BEARER_SET_UNKNOWN)) == 0) |
|
2038 { |
|
2039 *ptrTempField = KCommDbBearerUnknown; |
|
2040 } |
|
2041 else if (aSetting.CompareF(TPtrC(BEARER_SET_CSD)) == 0) |
|
2042 { |
|
2043 *ptrTempField = KCommDbBearerCSD; |
|
2044 } |
|
2045 else if (aSetting.CompareF(TPtrC(BEARER_SET_WCDMA)) == 0) |
|
2046 { |
|
2047 *ptrTempField = KCommDbBearerWcdma; |
|
2048 } |
|
2049 else if (aSetting.CompareF(TPtrC(BEARER_SET_LAN)) == 0) |
|
2050 { |
|
2051 *ptrTempField = KCommDbBearerLAN; |
|
2052 } |
|
2053 else if (aSetting.CompareF(TPtrC(BEARER_SET_PAN)) == 0) |
|
2054 { |
|
2055 *ptrTempField = KCommDbBearerPAN; |
|
2056 } |
|
2057 else if (aSetting.CompareF(TPtrC(BEARER_SET_WLAN)) == 0) |
|
2058 { |
|
2059 *ptrTempField = KCommDbBearerWLAN; |
|
2060 } |
|
2061 /* else if (aSetting.CompareF(TPtrC(BEARER_SET_PSD)) == 0) |
|
2062 { |
|
2063 *ptrTempField = ; |
|
2064 }*/ |
|
2065 else if (aSetting.CompareF(TPtrC(BEARER_SET_VIRTUAL)) == 0) |
|
2066 { |
|
2067 *ptrTempField = KCommDbBearerVirtual; |
|
2068 } |
|
2069 else |
|
2070 { |
|
2071 return EFalse; |
|
2072 } |
|
2073 TUint32 pColumnV; |
|
2074 pColumnV = *ptrTempField; |
|
2075 gMsg->Dbg(_L(" Column %S old value %S"), &aColumn, &aSetting); |
|
2076 gMsg->Dbg(_L(" Column %S new value %d"), &column, pColumnV); |
|
2077 gMsg->Msg(_L(" Column [%S] set to [%d]"), &aColumn, pColumnV); |
|
2078 return ETrue; |
|
2079 } |
|
2080 |
|
2081 return EFalse; |
|
2082 } |
|
2083 |
|
2084 TBool DBAccess::ConvertPANEnums(CMDBElement* aPtrField,TPtrC& aColumn,TPtrC& aSetting,TMDBAttributeFlags /*aAttribute*/) |
|
2085 { |
|
2086 CMDBField<TUint32>* ptrTempField = (CMDBField<TUint32>*)aPtrField; |
|
2087 |
|
2088 TBool ret(EFalse); |
|
2089 |
|
2090 if ((aColumn.Compare(TPtrC(PAN_LOCAL_ROLE)) == 0) || |
|
2091 (aColumn.Compare(TPtrC(PAN_PEER_ROLE)) == 0)) |
|
2092 { |
|
2093 TBuf<MAX_COL_NAME_LEN> columnValue; |
|
2094 TUint32 i(0); |
|
2095 |
|
2096 columnValue = ENUM_PAN_ROLEArray[i]; |
|
2097 |
|
2098 while (columnValue.Compare(TPtrC(NO_MORE_RECORDS)) != 0) |
|
2099 { |
|
2100 |
|
2101 if (aSetting.Compare(TPtrC(PAN_ROLE_U)) == 0) |
|
2102 { |
|
2103 *ptrTempField = EPanRoleU; |
|
2104 ret = ETrue; |
|
2105 } |
|
2106 else if (aSetting.Compare(TPtrC(PAN_ROLE_GN)) == 0) |
|
2107 { |
|
2108 *ptrTempField = EPanRoleGn; |
|
2109 ret = ETrue; |
|
2110 } |
|
2111 else if (aSetting.Compare(TPtrC(PAN_ROLE_NAP)) == 0) |
|
2112 { |
|
2113 *ptrTempField = EPanRoleNap; |
|
2114 ret = ETrue; |
|
2115 } |
|
2116 else if (aSetting.Compare(TPtrC(PAN_ROLE_UNKNOWN)) == 0) |
|
2117 { |
|
2118 *ptrTempField = EPanRoleUnknown; |
|
2119 ret = ETrue; |
|
2120 } |
|
2121 |
|
2122 if(ret) |
|
2123 { |
|
2124 TUint32 pColumnV; |
|
2125 pColumnV = *ptrTempField; |
|
2126 gMsg->Msg(_L(" Column [%S] set to [%d]"), &aColumn, pColumnV); |
|
2127 return ret; |
|
2128 } |
|
2129 columnValue = ENUM_PAN_ROLEArray[++i]; |
|
2130 } |
|
2131 } |
|
2132 |
|
2133 return ret; |
|
2134 } |
|
2135 |
|
2136 |
|
2137 TUint32 DBAccess::FindTableIdL(TDesC& aTableName) |
|
2138 { |
|
2139 TInt i(0); |
|
2140 |
|
2141 //TBuf<MAX_COL_VAL_LEN> table = tableArray[i]; |
|
2142 |
|
2143 TBuf<MAX_COL_VAL_LEN> table = ( (iIsXML) ? xmlTableArray[i] |
|
2144 : tableArray[i] ); |
|
2145 |
|
2146 while (table.Compare(TPtrC(NO_MORE_RECORDS)) != 0) |
|
2147 { |
|
2148 if(table.CompareF(aTableName) == 0) |
|
2149 { |
|
2150 return elementIdArray[i]; |
|
2151 } |
|
2152 //table = tableArray[++i]; |
|
2153 |
|
2154 table = ( (iIsXML) ? xmlTableArray[++i] |
|
2155 : tableArray[++i] ); |
|
2156 } |
|
2157 |
|
2158 //This means we havent found the table yet...so it could be a user defined record |
|
2159 CMDBGenericRecord* genericRecord = static_cast<CMDBGenericRecord *>(CCDRecordBase::RecordFactoryL(0)); |
|
2160 CleanupStack::PushL(genericRecord); |
|
2161 genericRecord->InitializeL(aTableName, NULL); |
|
2162 genericRecord->LoadL(*iDbSession); |
|
2163 TUint32 tableid = genericRecord->TableId(); |
|
2164 CleanupStack::PopAndDestroy(genericRecord); |
|
2165 return tableid; |
|
2166 } |
|
2167 |
|
2168 TBool DBAccess::SetLinkedRecord(TUint32 aIndex, CMDBElement* aPtrField,TPtrC& aColumn, TPtrC& aSetting, TMDBAttributeFlags /*aAttribute*/) |
|
2169 { |
|
2170 TBool ret(EFalse); |
|
2171 TBool linkByTag(EFalse); |
|
2172 TUint32 i(0); |
|
2173 |
|
2174 CMDBField<TUint32>* ptrTempField = (CMDBField<TUint32>*)aPtrField; |
|
2175 |
|
2176 while(TPtrC(LinkRecordsArray[aIndex][i]).CompareF(TPtrC(NO_MORE_RECORDS)) != 0) |
|
2177 { |
|
2178 if(aColumn.CompareF(TPtrC(LinkRecordsArray[aIndex][i++])) == 0) |
|
2179 { |
|
2180 //support for "Link.Table.Id" and "Table.Id" paterns |
|
2181 const TUint KTableColumnSeperator = '.'; |
|
2182 TInt pos = aSetting.Locate(TChar(KTableColumnSeperator)); |
|
2183 |
|
2184 if (pos != KErrNotFound) |
|
2185 { |
|
2186 TBuf<KCommsDbSvrMaxColumnNameLength> buffer = aSetting.Left(pos); |
|
2187 |
|
2188 if(buffer.CompareF(TPtrC(KTableLinkSeparator)) == 0) |
|
2189 { |
|
2190 #ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY |
|
2191 //found a link by tag linking. Instead of this the resolved TableName.RecId |
|
2192 //format should be used if the resolver object is present... |
|
2193 TBool foundThePair = EFalse; |
|
2194 |
|
2195 if (iLnkByTagRes) |
|
2196 //ok, we have the resolver object |
|
2197 { |
|
2198 const HBufC* theResolvedPair = iLnkByTagRes->ResolvedIdForTagLink(aSetting); |
|
2199 |
|
2200 if ( 0 < theResolvedPair->Size() ) |
|
2201 //ok, found the pair, let's use this... |
|
2202 { |
|
2203 foundThePair = ETrue; |
|
2204 |
|
2205 aSetting.Set(*theResolvedPair); |
|
2206 //search for the '.' character once again... |
|
2207 pos = aSetting.Locate(TChar(KTableColumnSeperator)); |
|
2208 |
|
2209 buffer = aSetting.Left(pos); |
|
2210 |
|
2211 } |
|
2212 } |
|
2213 |
|
2214 if (!foundThePair) |
|
2215 //hm.... Didn't find the pair for the link by tag linking. Let's try to handle |
|
2216 //it by this way... |
|
2217 { |
|
2218 #endif //SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY |
|
2219 |
|
2220 linkByTag = ETrue; |
|
2221 |
|
2222 // search for next separator that will define table name |
|
2223 TPtrC tableName = aSetting.Mid(pos+1); |
|
2224 |
|
2225 TInt posTableName = tableName.Locate(TChar(KTableColumnSeperator)); |
|
2226 |
|
2227 if (posTableName != KErrNotFound) |
|
2228 { |
|
2229 // extract table name to buffer |
|
2230 buffer = aSetting.Mid(pos+1, posTableName); |
|
2231 // adjust position |
|
2232 pos += posTableName +1; |
|
2233 } |
|
2234 else |
|
2235 { |
|
2236 return ret; |
|
2237 } |
|
2238 #ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY |
|
2239 } |
|
2240 #endif //SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY |
|
2241 } |
|
2242 |
|
2243 TPtrC id(aSetting.Mid(pos + 1)); |
|
2244 |
|
2245 TLex lex(id); |
|
2246 TUint32 recordid; |
|
2247 lex.Val(recordid,EDecimal); |
|
2248 |
|
2249 TUint32 linkedfield(0); |
|
2250 //now we have a table name and the record id.. |
|
2251 TRAPD(err, linkedfield = FindTableIdL(buffer);) |
|
2252 |
|
2253 if(err == KErrNone) |
|
2254 { |
|
2255 if (linkByTag) |
|
2256 { |
|
2257 // for linked by tag format is Linked flag | TableId | Tag |
|
2258 //linkedfield |= KLinkableFlagTag | recordid; |
|
2259 linkedfield = KLinkableFlagTag | recordid; |
|
2260 } |
|
2261 else |
|
2262 { |
|
2263 // for linked by record id format is ElementId |
|
2264 linkedfield |= ((recordid << 8) & KCDMaskShowRecordId) | KCDMaskShowFieldType; |
|
2265 } |
|
2266 |
|
2267 *ptrTempField = linkedfield; |
|
2268 ret = ETrue; |
|
2269 } |
|
2270 else |
|
2271 { |
|
2272 ret = EFalse; |
|
2273 } |
|
2274 } |
|
2275 } |
|
2276 } |
|
2277 |
|
2278 if(ret) |
|
2279 { |
|
2280 TUint32 pColumnV = *ptrTempField; |
|
2281 gMsg->Msg(_L("Column [%S] set to [%08x] was [%S]"), &aColumn, pColumnV, &aSetting); |
|
2282 } |
|
2283 |
|
2284 return ret; |
|
2285 } |
|
2286 |
|
2287 TBool DBAccess::ConvertIapPrioritySelectionPolicyEnums(CMDBElement* /*aPtrField*/,TPtrC& aColumn, TPtrC& /*aSetting*/, TMDBAttributeFlags /*aAttribute*/) |
|
2288 { |
|
2289 TInt tempType(0); |
|
2290 CMDBElement* ptrField = NULL; |
|
2291 TRAPD(ret,(ptrField = (iTable->iRecords[iTable->iRecords.Count()-1])->GetFieldByNameL(TPtrC(KCDTypeNameIapCountName),tempType))); |
|
2292 |
|
2293 //if ok update counter, otherwise ignore everything |
|
2294 if (ret==KErrNone) |
|
2295 { |
|
2296 CMDBField<TUint32>* ptrTempField = (CMDBField<TUint32>*)ptrField; |
|
2297 if (aColumn.Compare(TPtrC(KCDTypeNameIap1Name)) == 0) |
|
2298 { |
|
2299 ASSERT(*ptrTempField==0); |
|
2300 *ptrTempField = 1; |
|
2301 } |
|
2302 else if (aColumn.Compare(TPtrC(KCDTypeNameIap2Name)) == 0) |
|
2303 { |
|
2304 ASSERT(*ptrTempField==1); |
|
2305 *ptrTempField = 2; |
|
2306 } |
|
2307 else if (aColumn.Compare(TPtrC(KCDTypeNameIap3Name)) == 0) |
|
2308 { |
|
2309 ASSERT(*ptrTempField==2); |
|
2310 *ptrTempField = 3; |
|
2311 } |
|
2312 else if (aColumn.Compare(TPtrC(KCDTypeNameIap4Name)) == 0) |
|
2313 { |
|
2314 ASSERT(*ptrTempField==3); |
|
2315 *ptrTempField = 4; |
|
2316 } |
|
2317 else if (aColumn.Compare(TPtrC(KCDTypeNameIap5Name)) == 0) |
|
2318 { |
|
2319 ASSERT(*ptrTempField==4); |
|
2320 *ptrTempField = 5; |
|
2321 } |
|
2322 else if (aColumn.Compare(TPtrC(KCDTypeNameIap6Name)) == 0) |
|
2323 { |
|
2324 ASSERT(*ptrTempField==5); |
|
2325 *ptrTempField = 6; |
|
2326 } |
|
2327 else if (aColumn.Compare(TPtrC(KCDTypeNameIap7Name)) == 0) |
|
2328 { |
|
2329 ASSERT(*ptrTempField==6); |
|
2330 *ptrTempField = 7; |
|
2331 } |
|
2332 else if (aColumn.Compare(TPtrC(KCDTypeNameIap8Name)) == 0) |
|
2333 { |
|
2334 ASSERT(*ptrTempField==7); |
|
2335 *ptrTempField = 8; |
|
2336 } |
|
2337 else if (aColumn.Compare(TPtrC(KCDTypeNameIap9Name)) == 0) |
|
2338 { |
|
2339 ASSERT(*ptrTempField==8); |
|
2340 *ptrTempField = 9; |
|
2341 } |
|
2342 else if (aColumn.Compare(TPtrC(KCDTypeNameIap10Name)) == 0) |
|
2343 { |
|
2344 ASSERT(*ptrTempField==9); |
|
2345 *ptrTempField = 10; |
|
2346 } |
|
2347 else if (aColumn.Compare(TPtrC(KCDTypeNameIap11Name)) == 0) |
|
2348 { |
|
2349 ASSERT(*ptrTempField==10); |
|
2350 *ptrTempField = 11; |
|
2351 } |
|
2352 else if (aColumn.Compare(TPtrC(KCDTypeNameIap12Name)) == 0) |
|
2353 { |
|
2354 ASSERT(*ptrTempField==11); |
|
2355 *ptrTempField = 12; |
|
2356 } |
|
2357 else if (aColumn.Compare(TPtrC(KCDTypeNameIap13Name)) == 0) |
|
2358 { |
|
2359 ASSERT(*ptrTempField==12); |
|
2360 *ptrTempField = 13; |
|
2361 } |
|
2362 else if (aColumn.Compare(TPtrC(KCDTypeNameIap14Name)) == 0) |
|
2363 { |
|
2364 ASSERT(*ptrTempField==13); |
|
2365 *ptrTempField = 14; |
|
2366 } |
|
2367 else if (aColumn.Compare(TPtrC(KCDTypeNameIap15Name)) == 0) |
|
2368 { |
|
2369 ASSERT(*ptrTempField==14); |
|
2370 *ptrTempField = 15; |
|
2371 } |
|
2372 } |
|
2373 |
|
2374 //always return EFalse, as we only update the IAP counter here. |
|
2375 return EFalse; |
|
2376 } |
|
2377 #ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY |
|
2378 TBool DBAccess::ConvertApPrioritySelectionPolicyEnums(CMDBElement* /*aPtrField*/,TPtrC& aColumn, TPtrC& /*aSetting*/, TMDBAttributeFlags /*aAttribute*/) |
|
2379 { |
|
2380 TInt tempType(0); |
|
2381 CMDBElement* ptrField = NULL; |
|
2382 TRAPD(ret,(ptrField = (iTable->iRecords[iTable->iRecords.Count()-1])->GetFieldByNameL(TPtrC(KCDTypeNameApCountName),tempType))); |
|
2383 |
|
2384 //if ok update counter, otherwise ignore everything |
|
2385 if (ret==KErrNone) |
|
2386 { |
|
2387 CMDBField<TUint32>* ptrTempField = (CMDBField<TUint32>*)ptrField; |
|
2388 if (aColumn.Compare(TPtrC(KCDTypeNameAp1Name)) == 0) |
|
2389 { |
|
2390 ASSERT(*ptrTempField==0); |
|
2391 *ptrTempField = 1; |
|
2392 } |
|
2393 else if (aColumn.Compare(TPtrC(KCDTypeNameAp2Name)) == 0) |
|
2394 { |
|
2395 ASSERT(*ptrTempField==1); |
|
2396 *ptrTempField = 2; |
|
2397 } |
|
2398 else if (aColumn.Compare(TPtrC(KCDTypeNameAp3Name)) == 0) |
|
2399 { |
|
2400 ASSERT(*ptrTempField==2); |
|
2401 *ptrTempField = 3; |
|
2402 } |
|
2403 else if (aColumn.Compare(TPtrC(KCDTypeNameAp4Name)) == 0) |
|
2404 { |
|
2405 ASSERT(*ptrTempField==3); |
|
2406 *ptrTempField = 4; |
|
2407 } |
|
2408 else if (aColumn.Compare(TPtrC(KCDTypeNameAp5Name)) == 0) |
|
2409 { |
|
2410 ASSERT(*ptrTempField==4); |
|
2411 *ptrTempField = 5; |
|
2412 } |
|
2413 else if (aColumn.Compare(TPtrC(KCDTypeNameAp6Name)) == 0) |
|
2414 { |
|
2415 ASSERT(*ptrTempField==5); |
|
2416 *ptrTempField = 6; |
|
2417 } |
|
2418 else if (aColumn.Compare(TPtrC(KCDTypeNameAp7Name)) == 0) |
|
2419 { |
|
2420 ASSERT(*ptrTempField==6); |
|
2421 *ptrTempField = 7; |
|
2422 } |
|
2423 else if (aColumn.Compare(TPtrC(KCDTypeNameAp8Name)) == 0) |
|
2424 { |
|
2425 ASSERT(*ptrTempField==7); |
|
2426 *ptrTempField = 8; |
|
2427 } |
|
2428 else if (aColumn.Compare(TPtrC(KCDTypeNameAp9Name)) == 0) |
|
2429 { |
|
2430 ASSERT(*ptrTempField==8); |
|
2431 *ptrTempField = 9; |
|
2432 } |
|
2433 else if (aColumn.Compare(TPtrC(KCDTypeNameAp10Name)) == 0) |
|
2434 { |
|
2435 ASSERT(*ptrTempField==9); |
|
2436 *ptrTempField = 10; |
|
2437 } |
|
2438 else if (aColumn.Compare(TPtrC(KCDTypeNameAp11Name)) == 0) |
|
2439 { |
|
2440 ASSERT(*ptrTempField==10); |
|
2441 *ptrTempField = 11; |
|
2442 } |
|
2443 else if (aColumn.Compare(TPtrC(KCDTypeNameAp12Name)) == 0) |
|
2444 { |
|
2445 ASSERT(*ptrTempField==11); |
|
2446 *ptrTempField = 12; |
|
2447 } |
|
2448 else if (aColumn.Compare(TPtrC(KCDTypeNameAp13Name)) == 0) |
|
2449 { |
|
2450 ASSERT(*ptrTempField==12); |
|
2451 *ptrTempField = 13; |
|
2452 } |
|
2453 else if (aColumn.Compare(TPtrC(KCDTypeNameAp14Name)) == 0) |
|
2454 { |
|
2455 ASSERT(*ptrTempField==13); |
|
2456 *ptrTempField = 14; |
|
2457 } |
|
2458 else if (aColumn.Compare(TPtrC(KCDTypeNameAp15Name)) == 0) |
|
2459 { |
|
2460 ASSERT(*ptrTempField==14); |
|
2461 *ptrTempField = 15; |
|
2462 } |
|
2463 } |
|
2464 |
|
2465 //always return EFalse, as we only update the IAP counter here. |
|
2466 return EFalse; |
|
2467 } |
|
2468 #endif // SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY |
|
2469 |
|
2470 TBool DBAccess::IsConnectionPrefValid(CCDConnectionPrefsRecord& aConnectionPrefRecord) |
|
2471 { |
|
2472 |
|
2473 gMsg->Dbg(_L(" Dialog preference set to %d"), (TInt)aConnectionPrefRecord.iDialogPref); |
|
2474 gMsg->Dbg(_L(" IAP ID set to %d"), (TInt)aConnectionPrefRecord.iDefaultIAP); |
|
2475 gMsg->Dbg(_L(" Bearer Direction set to %d"),(TInt)aConnectionPrefRecord.iDirection); |
|
2476 gMsg->Dbg(_L(" Bearer Set set to %d"), (TInt)aConnectionPrefRecord.iBearerSet); |
|
2477 |
|
2478 |
|
2479 gMsg->Dbg(_L(" Checking preference fields...")); |
|
2480 |
|
2481 if (aConnectionPrefRecord.iRanking == BADNUMVAL || |
|
2482 aConnectionPrefRecord.iDirection == ECommDbConnectionDirectionUnknown || |
|
2483 (TCommDbDialogPref&)aConnectionPrefRecord.iDialogPref == ECommDbDialogPrefUnknown || |
|
2484 aConnectionPrefRecord.iBearerSet == BADNUMVAL || |
|
2485 aConnectionPrefRecord.iDefaultIAP == BADNUMVAL) |
|
2486 { |
|
2487 iLastError = E_NOTENOUGHDATA; |
|
2488 LastErrorMessage.Set(errorCode[E_NOTENOUGHDATA]); |
|
2489 return EFalse; |
|
2490 } |
|
2491 |
|
2492 gMsg->Msg(_L("All preference fields valid")); |
|
2493 return ETrue; |
|
2494 } |
|
2495 |
|
2496 TBool DBAccess::ConvertWLANEnums(CMDBElement* aPtrField,TPtrC& aColumn,TPtrC& aSetting,TMDBAttributeFlags /*aAttribute*/) |
|
2497 { |
|
2498 TBool ret(EFalse); |
|
2499 |
|
2500 CMDBField<TUint32>* ptrTempField = (CMDBField<TUint32>*)aPtrField; |
|
2501 |
|
2502 if (aColumn.Compare(TPtrC(WLAN_ENCRYPTION_TYPE)) == 0) |
|
2503 { |
|
2504 TBuf<MAX_COL_NAME_LEN> columnValue; |
|
2505 TUint32 i(0); |
|
2506 columnValue = ENUM_WLAN_ENCRYPTION_TYPEArray[i]; |
|
2507 while (columnValue.Compare(TPtrC(NO_MORE_RECORDS)) != 0) |
|
2508 { |
|
2509 if(aSetting.Compare(columnValue) == 0) |
|
2510 { |
|
2511 *ptrTempField = ENUM_WLAN_ENCRYPTION_TYPE_VALArray[i]; |
|
2512 ret = ETrue; |
|
2513 break; |
|
2514 } |
|
2515 i++; |
|
2516 columnValue = ENUM_WLAN_ENCRYPTION_TYPEArray[i]; |
|
2517 } |
|
2518 } |
|
2519 else if (aColumn.Compare(TPtrC(WLAN_DIALOG_PREF)) == 0) |
|
2520 { |
|
2521 TUint32 i(0); |
|
2522 TBuf<MAX_COL_NAME_LEN> columnValue = ENUM_WLAN_DIALOG_PREFArray[i]; |
|
2523 while (columnValue.Compare(TPtrC(NO_MORE_RECORDS)) != 0) |
|
2524 { |
|
2525 if(aSetting.Compare(columnValue) == 0) |
|
2526 { |
|
2527 *ptrTempField = ENUM_WLAN_DIALOG_PREF_VALArray[i]; |
|
2528 ret = ETrue; |
|
2529 break; |
|
2530 } |
|
2531 i++; |
|
2532 columnValue = ENUM_WLAN_DIALOG_PREFArray[i]; |
|
2533 } |
|
2534 } |
|
2535 else if (aColumn.Compare(TPtrC(WLAN_NETWORK_TYPE)) == 0) |
|
2536 { |
|
2537 TUint32 i(0); |
|
2538 TBuf<MAX_COL_NAME_LEN> columnValue = ENUM_WLAN_NETWORK_TYPEArray[i]; |
|
2539 while (columnValue.Compare(TPtrC(NO_MORE_RECORDS)) != 0) |
|
2540 { |
|
2541 if(aSetting.Compare(columnValue) == 0) |
|
2542 { |
|
2543 *ptrTempField = ENUM_WLAN_NETWORK_TYPE_VALArray[i];; |
|
2544 ret = ETrue; |
|
2545 break; |
|
2546 } |
|
2547 i++; |
|
2548 columnValue = ENUM_WLAN_NETWORK_TYPEArray[i]; |
|
2549 } |
|
2550 } |
|
2551 else if (aColumn.Compare(TPtrC(WLAN_DES_TRANS_RATE)) == 0) |
|
2552 { |
|
2553 TUint32 i(0); |
|
2554 TBuf<MAX_COL_NAME_LEN> columnValue = ENUM_WLAN_DES_TRANS_RATEArray[i]; |
|
2555 while (columnValue.Compare(TPtrC(NO_MORE_RECORDS)) != 0) |
|
2556 { |
|
2557 if(aSetting.Compare(columnValue) == 0) |
|
2558 { |
|
2559 *ptrTempField = ENUM_WLAN_DES_TRANS_RATE_VALArray[i]; |
|
2560 ret = ETrue; |
|
2561 break; |
|
2562 } |
|
2563 i++; |
|
2564 columnValue = ENUM_WLAN_DES_TRANS_RATEArray[i]; |
|
2565 } |
|
2566 } |
|
2567 else if (aColumn.Compare(TPtrC(WLAN_POWERSAVE_MODE)) == 0) |
|
2568 { |
|
2569 TUint32 i(0); |
|
2570 TBuf<MAX_COL_NAME_LEN> columnValue = ENUM_WLAN_POWERSAVE_MODEArray[i]; |
|
2571 while (columnValue.Compare(TPtrC(NO_MORE_RECORDS)) != 0) |
|
2572 { |
|
2573 if(aSetting.Compare(columnValue) == 0) |
|
2574 { |
|
2575 *ptrTempField = ENUM_WLAN_POWERSAVE_MODE_VALArray[i]; |
|
2576 ret = ETrue; |
|
2577 break; |
|
2578 } |
|
2579 i++; |
|
2580 columnValue = ENUM_WLAN_POWERSAVE_MODEArray[i]; |
|
2581 } |
|
2582 } |
|
2583 else if (aColumn.Compare(TPtrC(WLAN_PREAMBLE_TYPE)) == 0) |
|
2584 { |
|
2585 TUint32 i(0); |
|
2586 TBuf<MAX_COL_NAME_LEN> columnValue = ENUM_WLAN_PREAMBLE_TYPEArray[i]; |
|
2587 while (columnValue.Compare(TPtrC(NO_MORE_RECORDS)) != 0) |
|
2588 { |
|
2589 if(aSetting.Compare(columnValue) == 0) |
|
2590 { |
|
2591 *ptrTempField = ENUM_WLAN_PREAMBLE_TYPE_VALArray[i]; |
|
2592 ret = ETrue; |
|
2593 break; |
|
2594 } |
|
2595 i++; |
|
2596 columnValue = ENUM_WLAN_PREAMBLE_TYPEArray[i]; |
|
2597 } |
|
2598 } |
|
2599 else if (aColumn.Compare(TPtrC(WLAN_REG_DOMAIN)) == 0 || aColumn.Compare(TPtrC(REGULATORY_DOMAIN)) == 0) |
|
2600 { |
|
2601 TUint32 i(0); |
|
2602 TBuf<MAX_COL_NAME_LEN> columnValue = ENUM_WLAN_REG_DOMAINArray[i]; |
|
2603 while (columnValue.Compare(TPtrC(NO_MORE_RECORDS)) != 0) |
|
2604 { |
|
2605 if(aSetting.Compare(columnValue) == 0) |
|
2606 { |
|
2607 *ptrTempField = ENUM_WLAN_REG_DOMAIN_VALArray[i]; |
|
2608 ret = ETrue; |
|
2609 break; |
|
2610 } |
|
2611 i++; |
|
2612 columnValue = ENUM_WLAN_REG_DOMAINArray[i]; |
|
2613 } |
|
2614 } |
|
2615 else if (aColumn.Compare(TPtrC(DEFAULT_REGULATORY_DOMAIN)) == 0) |
|
2616 { |
|
2617 TUint32 i(0); |
|
2618 TBuf<MAX_COL_NAME_LEN> columnValue = ENUM_WLAN_REG_DOMAINArray[i]; |
|
2619 while (columnValue.Compare(TPtrC(NO_MORE_RECORDS)) != 0) |
|
2620 { |
|
2621 if(aSetting.Compare(columnValue) == 0) |
|
2622 { |
|
2623 *ptrTempField = ENUM_WLAN_REG_DOMAIN_VALArray[i]; |
|
2624 ret = ETrue; |
|
2625 break; |
|
2626 } |
|
2627 i++; |
|
2628 columnValue = ENUM_WLAN_REG_DOMAINArray[i]; |
|
2629 } |
|
2630 } |
|
2631 else if (aColumn.Compare(TPtrC(WLAN_AUTHENTICATION_MODE)) == 0) |
|
2632 { |
|
2633 TUint32 i(0); |
|
2634 TBuf<MAX_COL_NAME_LEN> columnValue = ENUM_WLAN_AUTHENTICATION_MODEArray[i]; |
|
2635 while (columnValue.Compare(TPtrC(NO_MORE_RECORDS)) != 0) |
|
2636 { |
|
2637 if(aSetting.Compare(columnValue) == 0) |
|
2638 { |
|
2639 *ptrTempField = ENUM_WLAN_AUTHENTICATION_MODE_VALArray[i]; |
|
2640 ret = ETrue; |
|
2641 break; |
|
2642 } |
|
2643 i++; |
|
2644 columnValue = ENUM_WLAN_AUTHENTICATION_MODEArray[i]; |
|
2645 } |
|
2646 } |
|
2647 else if (aColumn.Compare(TPtrC(WLAN_ENCRYPTION_STATUS)) == 0) |
|
2648 { |
|
2649 TUint32 i(0); |
|
2650 TBuf<MAX_COL_NAME_LEN> columnValue = ENUM_WLAN_ENCRYPTION_STATUSArray[i]; |
|
2651 while (columnValue.Compare(TPtrC(NO_MORE_RECORDS)) != 0) |
|
2652 { |
|
2653 if(aSetting.Compare(columnValue) == 0) |
|
2654 { |
|
2655 *ptrTempField = ENUM_WLAN_BOOLEAN_VALArray[i]; |
|
2656 ret = ETrue; |
|
2657 break; |
|
2658 } |
|
2659 i++; |
|
2660 columnValue = ENUM_WLAN_ENCRYPTION_STATUSArray[i]; |
|
2661 } |
|
2662 } |
|
2663 else if (aColumn.Compare(TPtrC(WLAN_ALLOW_UNENCRYPT_MODE)) == 0) |
|
2664 { |
|
2665 TUint32 i(0); |
|
2666 TBuf<MAX_COL_NAME_LEN> columnValue = ENUM_WLAN_ALLOW_UNENCRYPT_MODEArray[i]; |
|
2667 while (columnValue.Compare(TPtrC(NO_MORE_RECORDS)) != 0) |
|
2668 { |
|
2669 if(aSetting.Compare(columnValue) == 0) |
|
2670 { |
|
2671 *ptrTempField = ENUM_WLAN_BOOLEAN_VALArray[i]; |
|
2672 ret = ETrue; |
|
2673 break; |
|
2674 } |
|
2675 i++; |
|
2676 columnValue = ENUM_WLAN_ALLOW_UNENCRYPT_MODEArray[i]; |
|
2677 } |
|
2678 } |
|
2679 else if (aColumn.Compare(TPtrC(WLAN_ALLOW_SHORT_PRE)) == 0) |
|
2680 { |
|
2681 TUint32 i(0); |
|
2682 TBuf<MAX_COL_NAME_LEN> columnValue = ENUM_WLAN_ALLOW_SHORT_PREArray[i]; |
|
2683 while (columnValue.Compare(TPtrC(NO_MORE_RECORDS)) != 0) |
|
2684 { |
|
2685 if(aSetting.Compare(columnValue) == 0) |
|
2686 { |
|
2687 *ptrTempField = ENUM_WLAN_BOOLEAN_VALArray[i]; |
|
2688 ret = ETrue; |
|
2689 break; |
|
2690 } |
|
2691 i++; |
|
2692 columnValue = ENUM_WLAN_ALLOW_SHORT_PREArray[i]; |
|
2693 } |
|
2694 } |
|
2695 |
|
2696 if(ret) |
|
2697 { |
|
2698 TUint32 pColumnV; |
|
2699 pColumnV = *ptrTempField; |
|
2700 gMsg->Msg(_L(" Column %S with enum value %S set to %d"), &aColumn, &aSetting, pColumnV); |
|
2701 } |
|
2702 return ret; |
|
2703 } |
|
2704 |
|
2705 TBool DBAccess::ConvertEAPSecEnums(CMDBElement* aPtrField,TPtrC& aColumn,TPtrC& aSetting,TMDBAttributeFlags /*aAttribute*/) |
|
2706 { |
|
2707 TBool ret(EFalse); |
|
2708 CMDBField<TUint32>* ptrTempField = (CMDBField<TUint32>*)aPtrField; |
|
2709 |
|
2710 if (aColumn.Compare(TPtrC(EAP_SEC_OUTER_EAP_TYPE)) == 0) |
|
2711 { |
|
2712 TBuf<MAX_COL_NAME_LEN> columnValue; |
|
2713 TUint32 i(0); |
|
2714 columnValue = ENUM_EAP_SEC_OUTER_EAP_TYPEArray[i]; |
|
2715 while (columnValue.Compare(TPtrC(NO_MORE_RECORDS)) != 0) |
|
2716 { |
|
2717 if(aSetting.Compare(columnValue) == 0) |
|
2718 { |
|
2719 *ptrTempField = ENUM_EAP_SEC_OUTER_EAP_TYPE_VALArray[i]; |
|
2720 ret = ETrue; |
|
2721 break; |
|
2722 } |
|
2723 i++; |
|
2724 columnValue = ENUM_EAP_SEC_OUTER_EAP_TYPEArray[i]; |
|
2725 } |
|
2726 } |
|
2727 if(ret) |
|
2728 { |
|
2729 TUint32 pColumnV; |
|
2730 pColumnV = *ptrTempField; |
|
2731 gMsg->Msg(_L(" Column %S with enum value %S set to %d"), &aColumn, &aSetting, pColumnV); |
|
2732 } |
|
2733 return ret; |
|
2734 } |
|
2735 |
|
2736 TBool DBAccess::ConvertTUNEAPSecEnums(CMDBElement* aPtrField,TPtrC& aColumn,TPtrC& aSetting,TMDBAttributeFlags /*aAttribute*/) |
|
2737 { |
|
2738 |
|
2739 TBool ret(EFalse); |
|
2740 CMDBField<TUint32>* ptrTempField = (CMDBField<TUint32>*)aPtrField; |
|
2741 |
|
2742 if (aColumn.Compare(TPtrC(TUN_EAP_INNERTYPE)) == 0) |
|
2743 { |
|
2744 TBuf<MAX_COL_NAME_LEN> columnValue; |
|
2745 TUint32 i(0); |
|
2746 columnValue = ENUM_TUN_EAP_INNERTYPEArray[i]; |
|
2747 while (columnValue.Compare(TPtrC(NO_MORE_RECORDS)) != 0) |
|
2748 { |
|
2749 if(aSetting.Compare(columnValue) == 0) |
|
2750 { |
|
2751 *ptrTempField = ENUM_TUN_EAP_INNERTYPE_VALArray[i]; |
|
2752 ret = ETrue; |
|
2753 break; |
|
2754 } |
|
2755 i++; |
|
2756 columnValue = ENUM_TUN_EAP_INNERTYPEArray[i]; |
|
2757 } |
|
2758 } |
|
2759 if(ret) |
|
2760 { |
|
2761 TUint32 pColumnV; |
|
2762 pColumnV = *ptrTempField; |
|
2763 gMsg->Msg(_L(" Column %S with enum value %S set to %d"), &aColumn, &aSetting, pColumnV); |
|
2764 } |
|
2765 return ret; |
|
2766 } |
|
2767 |
|
2768 TBool DBAccess::TemplateFieldPresentL(TMDBElementId aElementId) |
|
2769 /** |
|
2770 Check if a particular field is present in the template record (if any) for the current table. |
|
2771 |
|
2772 @param aElementId table and column id of field to check |
|
2773 @return ETrue if field exists, else EFalse |
|
2774 */ |
|
2775 { |
|
2776 // We assume that iTable has been setup with at least the first record of the current table |
|
2777 // being processed. |
|
2778 if (iTable && iTable->iRecords.Count() > 0) |
|
2779 { |
|
2780 const TInt KFirstRecord = 0; |
|
2781 const TUint KTemplateRecordId = 0; |
|
2782 const TMDBElementId id = iTable->iRecords[KFirstRecord]->ElementId(); |
|
2783 // Ccheck if the first record is a template record of the requested table. |
|
2784 if ((id & KCDMaskShowRecordId) == KTemplateRecordId && |
|
2785 (id & KCDMaskShowRecordType) == (aElementId & KCDMaskShowRecordType)) |
|
2786 { |
|
2787 // now check that the field itself is present and is set to a non-null value |
|
2788 CMDBElement *el = NULL; |
|
2789 TRAPD(err, el = iTable->iRecords[0]->GetFieldByIdL(aElementId)); |
|
2790 return err == KErrNone && el && !el->IsNull(); |
|
2791 } |
|
2792 } |
|
2793 return EFalse; |
|
2794 } |