54 EStateAfterImportUserPrivKey, |
45 EStateAfterImportUserPrivKey, |
55 EStateAttachCertificate, |
46 EStateAttachCertificate, |
56 EStateAfterAttachCertificate, |
47 EStateAfterAttachCertificate, |
57 EStateImportPinAndPol, |
48 EStateImportPinAndPol, |
58 EStateCreateVpnDestination, |
49 EStateCreateVpnDestination, |
59 EStateEndPolicyImport, |
50 EStateEndPolicyImport |
60 EStateGetPolicyProvisionService, |
|
61 EStateAfterGetPolicyProvisionService |
|
62 }; |
51 }; |
63 |
52 |
64 CPolicyImporter* CPolicyImporter::NewL(const RMessage2& aMessage, CVpnApiServant& aVpnApiServant, |
53 CPolicyImporter* CPolicyImporter::NewL(const RMessage2& aMessage, CVpnApiServant& aVpnApiServant, |
65 CPolicyStore& aPolicyStore, RFs& aFs) |
54 CPolicyStore& aPolicyStore, RFs& aFs) |
66 { |
55 { |
617 |
595 |
618 void CPolicyImporter::StateImportPinAndPolL() |
596 void CPolicyImporter::StateImportPinAndPolL() |
619 { |
597 { |
620 LOG_("-> CPolicyImporter::StateImportPinAndPolL()"); |
598 LOG_("-> CPolicyImporter::StateImportPinAndPolL()"); |
621 SetCurrState(EStateImportPinAndPol); |
599 SetCurrState(EStateImportPinAndPol); |
622 HBufC* pinFile; |
600 |
623 HBufC* polFile; |
601 HBufC* pinFile = iFileUtil.MakeFileNameLC(iImportDir, iCurrPolicyId, KPinFileExt); |
624 if ( !iAgileProvision ) |
602 HBufC* polFile = iFileUtil.MakeFileNameLC(iImportDir, iCurrPolicyId, KPolFileExt); |
625 { |
|
626 pinFile = iFileUtil.MakeFileNameLC(iImportDir, iCurrPolicyId, KPinFileExt); |
|
627 polFile = iFileUtil.MakeFileNameLC(iImportDir, iCurrPolicyId, KPolFileExt); |
|
628 } |
|
629 else |
|
630 { |
|
631 pinFile = iFileUtil.MakeFileNameLC(KTempDirectory(), KAgileProvisionPinFileName(), KNullDesc()); |
|
632 polFile = iFileUtil.MakeFileNameLC(KTempDirectory(), KAgileProvisionPolicyFileName(), KNullDesc()); |
|
633 |
|
634 HBufC8* infoData=NULL; |
|
635 |
|
636 if ( iFileUtil.FileExists(*polFile) ) |
|
637 { |
|
638 infoData=GetPolicyNameL(polFile); |
|
639 CleanupStack::PushL(infoData); |
|
640 } |
|
641 else |
|
642 User::Leave(KErrNotFound); |
|
643 |
|
644 |
|
645 HBufC8* pinFileData = HBufC8::NewLC(KNullDesc().Length() + KPinFileNameTitle().Length() + KCRLF().Length() + infoData->Length()); |
|
646 TPtr8 pinFilePtr (pinFileData->Des()) ; |
|
647 pinFilePtr.Append(KPinFileNameTitle); |
|
648 pinFilePtr.Append(KCRLF); |
|
649 pinFilePtr.Append(*infoData); |
|
650 |
|
651 iFileUtil.SaveFileDataL(*pinFile, *pinFileData); |
|
652 |
|
653 CleanupStack::PopAndDestroy(pinFileData); |
|
654 CleanupStack::PopAndDestroy(infoData); |
|
655 } |
|
656 |
|
657 |
603 |
658 if (!iFileUtil.FileExists(*pinFile)) |
604 if (!iFileUtil.FileExists(*pinFile)) |
659 { |
605 { |
660 LOG_("<- CPolicyImporter::StateImportPinAndPolL() LEAVE: KVpnErrNoPolicyInfoFile"); |
606 LOG_("<- CPolicyImporter::StateImportPinAndPolL() LEAVE: KVpnErrNoPolicyInfoFile"); |
661 User::Leave(KVpnErrNoPolicyInfoFile); |
607 User::Leave(KVpnErrNoPolicyInfoFile); |
696 void CPolicyImporter::StateCreateVpnDestinationL() |
637 void CPolicyImporter::StateCreateVpnDestinationL() |
697 { |
638 { |
698 LOG_("-> CPolicyImporter::StateCreateVpnDestinationL()"); |
639 LOG_("-> CPolicyImporter::StateCreateVpnDestinationL()"); |
699 SetCurrState(EStateCreateVpnDestination); |
640 SetCurrState(EStateCreateVpnDestination); |
700 |
641 |
701 //Gets the IAP name from policy name |
642 //Gets the IAP name from policy name |
702 TVpnPolicyInfo* policyInfo = new (ELeave) TVpnPolicyInfo; |
643 TVpnPolicyInfo* policyInfo = new (ELeave) TVpnPolicyInfo; |
703 CleanupDeletePushL(policyInfo); |
644 CleanupDeletePushL(policyInfo); |
704 |
645 |
705 User::LeaveIfError(iPolicyStore.GetPolicyInfo(*iNewPolicyId, *policyInfo)); |
646 User::LeaveIfError(iPolicyStore.GetPolicyInfo(*iNewPolicyId, *policyInfo)); |
706 TBool iapExist(EFalse); |
647 |
707 if ( !iAgileProvision ) |
648 CmManagerUtils::CreateVPNConnectionMethodToIntranetL(*policyInfo, |
708 TUint32 provisionIapId = CmManagerUtils::CreateVPNConnectionMethodToIntranetL(*policyInfo, |
649 *(iVpnApiServant.iEventLogger)); |
709 *(iVpnApiServant.iEventLogger)); |
650 |
710 else |
651 CleanupStack::PopAndDestroy(); //policyInfo |
711 { |
|
712 |
|
713 if ( iAgileProvisionAPId > 0 ) |
|
714 { |
|
715 iapExist=CmManagerUtils::ProvisionIAPNameExistL(iAgileProvisionAPId); |
|
716 } |
|
717 |
|
718 if ( !iapExist || iAgileProvisionAPId == 0) |
|
719 { |
|
720 TUint32 provisionIapId = CmManagerUtils::CreateVPNConnectionMethodToIntranetL(*policyInfo, |
|
721 *(iVpnApiServant.iEventLogger)); |
|
722 |
|
723 TFileName serverSettingsFile; |
|
724 User::LeaveIfError(iFs.PrivatePath(serverSettingsFile)); |
|
725 |
|
726 serverSettingsFile.Append(KProvisionServerSettings); |
|
727 |
|
728 if ( iFileUtil.FileExists(serverSettingsFile) ) |
|
729 { |
|
730 _LIT(KCRLF, "\n"); |
|
731 RFile serverFile; |
|
732 User::LeaveIfError(serverFile.Open(iFs,serverSettingsFile, EFileRead)); |
|
733 |
|
734 TFileText tx; |
|
735 tx.Set(serverFile); |
|
736 |
|
737 TInt fileSize; |
|
738 User::LeaveIfError(serverFile.Size(fileSize)); |
|
739 |
|
740 HBufC* serverUrlBuf = HBufC::NewLC(fileSize); |
|
741 |
|
742 TPtr serverUrlPtr=serverUrlBuf->Des(); |
|
743 |
|
744 User::LeaveIfError(tx.Read(serverUrlPtr)); |
|
745 |
|
746 |
|
747 HBufC* serverNameBuf = HBufC::NewLC(fileSize); |
|
748 TPtr serverNamePtr=serverNameBuf->Des(); |
|
749 |
|
750 User::LeaveIfError(tx.Read(serverNamePtr)); |
|
751 |
|
752 |
|
753 TBuf<KMaxIapLength> iapIdData; |
|
754 User::LeaveIfError(tx.Read(iapIdData)); |
|
755 |
|
756 TBuf<KMaxIapLength> iapModeData; |
|
757 User::LeaveIfError(tx.Read(iapModeData)); |
|
758 |
|
759 HBufC* policyFileNameBuf = HBufC::NewLC(fileSize); |
|
760 |
|
761 TPtr policyFileNamePtr = policyFileNameBuf->Des(); |
|
762 User::LeaveIfError(tx.Read(policyFileNamePtr)); |
|
763 |
|
764 serverFile.Close(); |
|
765 |
|
766 TBuf<KMaxIapLength> agileIapIdStr; |
|
767 agileIapIdStr.Num(provisionIapId); |
|
768 |
|
769 HBufC* serverFileBuf = HBufC::NewL(fileSize + KCRLF().Length() + agileIapIdStr.Length()); |
|
770 CleanupStack::PushL(serverFileBuf); |
|
771 TPtr tPtr(serverFileBuf->Des()); |
|
772 tPtr.Copy(serverUrlPtr); |
|
773 tPtr.Append(KCRLF); |
|
774 tPtr.Append(serverNamePtr); |
|
775 tPtr.Append(KCRLF); |
|
776 tPtr.Append(iapIdData); |
|
777 tPtr.Append(KCRLF); |
|
778 tPtr.Append(iapModeData); |
|
779 tPtr.Append(KCRLF); |
|
780 tPtr.Append(policyFileNamePtr); |
|
781 tPtr.Append(KCRLF); |
|
782 tPtr.AppendNum(provisionIapId); |
|
783 |
|
784 RFile file; |
|
785 CleanupClosePushL(file); |
|
786 User::LeaveIfError(file.Replace(iFs, serverSettingsFile, EFileWrite)); |
|
787 TPtrC8 ptr8 ( (TUint8*) tPtr.Ptr(), tPtr.Size() ); |
|
788 file.Write ( ptr8 ); |
|
789 file.Close(); |
|
790 |
|
791 CleanupStack::PopAndDestroy(1); //file |
|
792 CleanupStack::PopAndDestroy(serverFileBuf); |
|
793 CleanupStack::PopAndDestroy(policyFileNameBuf); |
|
794 CleanupStack::PopAndDestroy(serverNameBuf); |
|
795 CleanupStack::PopAndDestroy(serverUrlBuf); |
|
796 |
|
797 } |
|
798 } |
|
799 } |
|
800 |
|
801 CleanupStack::PopAndDestroy(policyInfo); |
|
802 GotoState(EStateEndPolicyImport); |
652 GotoState(EStateEndPolicyImport); |
803 |
653 |
804 LOG_("<- CPolicyImporter::StateCreateVpnDestinationL()"); |
654 LOG_("<- CPolicyImporter::StateCreateVpnDestinationL()"); |
805 } |
655 } |
806 |
656 |
816 |
666 |
817 HBufC* fileFilter = iFileUtil.MakeFileNameLC(iImportDir, iCurrPolicyId, KAllFilesPat); |
667 HBufC* fileFilter = iFileUtil.MakeFileNameLC(iImportDir, iCurrPolicyId, KAllFilesPat); |
818 iFileUtil.DeleteFilesL(*fileFilter); |
668 iFileUtil.DeleteFilesL(*fileFilter); |
819 |
669 |
820 CleanupStack::PopAndDestroy(); // fileFilter |
670 CleanupStack::PopAndDestroy(); // fileFilter |
821 if ( !iAgileProvision ) |
671 |
822 { |
672 LOG_EVENT_2B(R_VPN_MSG_INSTALLED_POLICY_FILE, iNewPolicyId, NULL, 0, iImportSinglePolicy); |
823 LOG_EVENT_2B(R_VPN_MSG_INSTALLED_POLICY_FILE, iNewPolicyId, NULL, 0, iImportSinglePolicy); |
673 |
824 } |
|
825 else |
|
826 { |
|
827 _LIT8(KPolicySever, "Policy server"); |
|
828 LOG_EVENT_2B(R_VPN_MSG_INSTALLED_POLICY_SERVER, iNewPolicyId, &KPolicySever(), KErrNone, EFalse); |
|
829 } |
|
830 GotoState(EStateBeginPolicyImport); |
674 GotoState(EStateBeginPolicyImport); |
831 LOG_("<- CPolicyImporter::StateEndPolicyImportL()"); |
675 LOG_("<- CPolicyImporter::StateEndPolicyImportL()"); |
832 } |
676 } |
833 |
|
834 void CPolicyImporter::SynchronizeVpnPolicyServerL() |
|
835 { |
|
836 |
|
837 GotoState(EStateGetPolicyProvisionService); |
|
838 } |
|
839 |
|
840 void CPolicyImporter::StateGetPolicyProvisionServiceL() |
|
841 { |
|
842 GetPolicyWsL(); |
|
843 SetNextState(EStateAfterGetPolicyProvisionService); |
|
844 |
|
845 } |
|
846 |
|
847 void CPolicyImporter::StateAfterGetPolicyProvisionServiceL() |
|
848 { |
|
849 |
|
850 if (iStatus != KErrNone) |
|
851 { |
|
852 User::Leave(iStatus.Int()); |
|
853 } |
|
854 delete iCurrCaCertList; |
|
855 iCurrCaCertList = NULL; |
|
856 iCurrCaCertList = new (ELeave) CArrayFixFlat<TFileName>(2); |
|
857 |
|
858 delete iCurrUserCertList; |
|
859 iCurrUserCertList = NULL; |
|
860 iCurrUserCertList = new (ELeave) CArrayFixFlat<TFileName>(2); |
|
861 |
|
862 iNewPolicyId = &iPolicyId; |
|
863 |
|
864 BuildPolicyIdListL(); |
|
865 iCurrPolicyId.Copy(iPolicyIdList->At(iCurrPolicyIdIndex)); |
|
866 iImportSinglePolicy = EFalse; |
|
867 iAgileProvision = ETrue; |
|
868 GotoState(EStateImportPinAndPol); |
|
869 |
|
870 } |
|
871 |
|
872 |
677 |
873 void CPolicyImporter::BuildPolicyIdListL() |
678 void CPolicyImporter::BuildPolicyIdListL() |
874 { |
679 { |
875 delete iPolicyIdList; |
680 delete iPolicyIdList; |
876 iPolicyIdList = NULL; |
681 iPolicyIdList = NULL; |
1346 issuerName=NULL; |
1151 issuerName=NULL; |
1347 currIndex++; |
1152 currIndex++; |
1348 } |
1153 } |
1349 |
1154 |
1350 return aCertFileArray->At(currCaIndex); |
1155 return aCertFileArray->At(currCaIndex); |
1351 } |
|
1352 |
1156 |
1353 |
|
1354 void CPolicyImporter::GetPolicyWsL() |
|
1355 { |
|
1356 |
|
1357 delete iAgileProvisionWs; |
|
1358 iImportDir=KTempDirectory(); |
|
1359 iFileUtil.CreateDirIfNeededL(iImportDir); |
|
1360 iAgileProvisionWs = CAgileProvisionWs::NewL(); |
|
1361 |
|
1362 TFileName serverSettingsFile; |
|
1363 User::LeaveIfError(iFs.PrivatePath(serverSettingsFile)); |
|
1364 |
|
1365 serverSettingsFile.Append(KProvisionServerSettings); |
|
1366 |
|
1367 HBufC8* serviceEndPoint; |
|
1368 |
|
1369 if ( iFileUtil.FileExists(serverSettingsFile) ) |
|
1370 { |
|
1371 |
|
1372 |
|
1373 RFile serverFile; |
|
1374 User::LeaveIfError(serverFile.Open(iFs,serverSettingsFile, EFileRead)); |
|
1375 |
|
1376 TFileText tx; |
|
1377 tx.Set(serverFile); |
|
1378 |
|
1379 TInt fileSize; |
|
1380 User::LeaveIfError(serverFile.Size(fileSize)); |
|
1381 |
|
1382 HBufC* serverUrlBuf = HBufC::NewLC(fileSize); |
|
1383 |
|
1384 TPtr serverUrlPtr=serverUrlBuf->Des(); |
|
1385 |
|
1386 User::LeaveIfError(tx.Read(serverUrlPtr)); |
|
1387 |
|
1388 HBufC8* serverUrl=iFileUtil.To8BitL(serverUrlPtr); |
|
1389 |
|
1390 CleanupStack::PopAndDestroy(serverUrlBuf); |
|
1391 |
|
1392 CleanupStack::PushL(serverUrl); |
|
1393 |
|
1394 |
|
1395 serviceEndPoint=HBufC8::NewL( KHTTPprefix().Length() + KServiceSuffix().Length() + serverUrlPtr.Length()); |
|
1396 CleanupStack::PushL(serviceEndPoint); |
|
1397 TPtr8 endPointPtr(serviceEndPoint->Des()); |
|
1398 endPointPtr=KHTTPprefix; |
|
1399 |
|
1400 // serverUrl ownership transfer |
|
1401 iAgileProvisionWs->SetServiceAddr(serverUrl); |
|
1402 endPointPtr.Append(*serverUrl); |
|
1403 endPointPtr.Append(KServiceSuffix); |
|
1404 |
|
1405 |
|
1406 HBufC* serverNameBuf = HBufC::NewLC(fileSize); |
|
1407 TPtr serverNamePtr=serverNameBuf->Des(); |
|
1408 |
|
1409 User::LeaveIfError(tx.Read(serverNamePtr)); |
|
1410 |
|
1411 CleanupStack::PopAndDestroy(serverNameBuf); |
|
1412 |
|
1413 TBuf<KMaxIapLength> iapIdData; |
|
1414 User::LeaveIfError(tx.Read(iapIdData)); |
|
1415 |
|
1416 TLex iapIdConverter(iapIdData); |
|
1417 TUint iapIdInt; |
|
1418 iapIdConverter.Val(iapIdInt); |
|
1419 |
|
1420 iAgileProvisionWs->GetPolicy( *serviceEndPoint, iapIdInt, iStatus ); |
|
1421 CleanupStack::PopAndDestroy(serviceEndPoint); |
|
1422 CleanupStack::Pop(serverUrl); |
|
1423 serverFile.Close(); |
|
1424 } |
|
1425 |
|
1426 |
|
1427 SetActive(); |
|
1428 |
|
1429 } |
|
1430 |
|
1431 HBufC8* CPolicyImporter::GetPolicyNameL(HBufC* aPolicyFileName) |
|
1432 { |
|
1433 HBufC8* infoData=NULL; |
|
1434 HBufC8* infoSection=NULL; |
|
1435 HBufC8* fileData=NULL; |
|
1436 if ( iFileUtil.FileExists(*aPolicyFileName) ) |
|
1437 { |
|
1438 fileData=iFileUtil.LoadFileDataL(*aPolicyFileName); |
|
1439 CleanupStack::PushL(fileData); |
|
1440 _LIT8(KInfo, "[INFO]"); |
|
1441 TInt i=(fileData->Find(KInfo)) + KInfo().Length() + KCRLF().Length(); |
|
1442 |
|
1443 infoSection=fileData->Right((fileData->Length())-i).AllocL(); |
|
1444 CleanupStack::PushL(infoSection); |
|
1445 TInt j=infoSection->Find(KCRLF); |
|
1446 |
|
1447 infoData=infoSection->Mid(0,j).AllocL(); |
|
1448 |
|
1449 CleanupStack::Pop(infoSection); |
|
1450 CleanupStack::Pop(fileData); |
|
1451 |
|
1452 delete infoSection; |
|
1453 delete fileData; |
|
1454 infoSection=NULL; |
|
1455 fileData=NULL; |
|
1456 |
|
1457 } |
|
1458 else |
|
1459 User::Leave(KErrNotFound); |
|
1460 |
|
1461 return infoData; |
|
1462 } |
|
1463 |
|
1464 |
|
1465 void CPolicyImporter::PatchPolicyProvisionL() |
|
1466 { |
|
1467 TPath privateDir; |
|
1468 User::LeaveIfError(iFs.PrivatePath(privateDir)); |
|
1469 |
|
1470 HBufC* policyServerSettingsFileName = HBufC::NewL(KProvisionServerSettings().Length() + privateDir.Length()); |
|
1471 CleanupStack::PushL(policyServerSettingsFileName); |
|
1472 TPtr fileNamePtr=policyServerSettingsFileName->Des(); |
|
1473 fileNamePtr.Append(privateDir); |
|
1474 fileNamePtr.Append(KProvisionServerSettings); |
|
1475 _LIT(KCRLF, "\n"); |
|
1476 if ( iFileUtil.FileExists(fileNamePtr) ) |
|
1477 { |
|
1478 |
|
1479 RFile serverFile; |
|
1480 User::LeaveIfError(serverFile.Open(iFs,fileNamePtr, EFileRead)); |
|
1481 |
|
1482 TFileText tx; |
|
1483 tx.Set(serverFile); |
|
1484 |
|
1485 TInt fileSize; |
|
1486 User::LeaveIfError(serverFile.Size(fileSize)); |
|
1487 |
|
1488 HBufC* serverUrlBuf = HBufC::NewLC(fileSize); |
|
1489 |
|
1490 TPtr serverUrlPtr=serverUrlBuf->Des(); |
|
1491 |
|
1492 User::LeaveIfError(tx.Read(serverUrlPtr)); |
|
1493 |
|
1494 HBufC* serverNameBuf = HBufC::NewLC(fileSize); |
|
1495 TPtr serverNamePtr=serverNameBuf->Des(); |
|
1496 |
|
1497 User::LeaveIfError(tx.Read(serverNamePtr)); |
|
1498 |
|
1499 |
|
1500 TBuf<KMaxIapLength> iapIdData; |
|
1501 User::LeaveIfError(tx.Read(iapIdData)); |
|
1502 |
|
1503 TBuf<KMaxIapLength> iapModeData; |
|
1504 User::LeaveIfError(tx.Read(iapModeData)); |
|
1505 |
|
1506 TBuf<KMaxIapLength> iapIdBuf; |
|
1507 |
|
1508 HBufC* policyFilePath; |
|
1509 HBufC* policyFileNameBuf = HBufC::NewLC(fileSize); |
|
1510 TPtr policyFileNamePtr = policyFileNameBuf->Des(); |
|
1511 |
|
1512 if ( tx.Read(policyFileNamePtr) == KErrNone ) |
|
1513 { |
|
1514 |
|
1515 tx.Read(iapIdBuf); |
|
1516 TLex iapIdConverter(iapIdBuf); |
|
1517 iapIdConverter.Val(iAgileProvisionAPId,EDecimal); |
|
1518 |
|
1519 policyFilePath = iFileUtil.MakeFileNameLC(privateDir, *policyFileNameBuf, KPolFileExt); |
|
1520 } |
|
1521 else |
|
1522 { |
|
1523 policyFilePath =iFileUtil.MakeFileNameLC(privateDir, *iNewPolicyId, KPolFileExt); |
|
1524 } |
|
1525 |
|
1526 serverFile.Close(); |
|
1527 |
|
1528 TBuf<KMaxIapLength> iapAgileIdStr; |
|
1529 //server configuration file includes installed policy file name and policy exists. |
|
1530 if ( (iAgileProvisionAPId > 0) && iFileUtil.FileExists(*policyFilePath) ) |
|
1531 { |
|
1532 iPolicyIdBuf.Append(*policyFileNameBuf); |
|
1533 iNewPolicyIdBuf=iPolicyIdBuf; |
|
1534 iPolicyStore.ReplacePolicyL(iPolicyIdBuf,*iNewPolicyId); |
|
1535 iNewPolicyId= &iNewPolicyIdBuf; |
|
1536 } |
|
1537 //either first configuration or policy removed |
|
1538 else |
|
1539 { |
|
1540 |
|
1541 HBufC* serverFileBuf = HBufC::NewL(fileSize + KCRLF().Length() + iNewPolicyId->Length() + KMaxIapLength); |
|
1542 CleanupStack::PushL(serverFileBuf); |
|
1543 TPtr tPtr(serverFileBuf->Des()); |
|
1544 tPtr.Copy(serverUrlPtr); |
|
1545 tPtr.Append(KCRLF); |
|
1546 tPtr.Append(serverNamePtr); |
|
1547 tPtr.Append(KCRLF); |
|
1548 tPtr.Append(iapIdData); |
|
1549 tPtr.Append(KCRLF); |
|
1550 tPtr.Append(iapModeData); |
|
1551 |
|
1552 //policy removed |
|
1553 if ( !iFileUtil.FileExists(*policyFilePath) ) |
|
1554 { |
|
1555 tPtr.Append(KCRLF); |
|
1556 tPtr.Append(*iNewPolicyId); |
|
1557 tPtr.Append(KCRLF); |
|
1558 iapAgileIdStr.Num(iAgileProvisionAPId); |
|
1559 tPtr.Append(iapAgileIdStr); |
|
1560 } |
|
1561 //first configuration |
|
1562 else |
|
1563 { |
|
1564 tPtr.Append(KCRLF); |
|
1565 tPtr.Append(*iNewPolicyId); |
|
1566 |
|
1567 } |
|
1568 RFile file; |
|
1569 CleanupClosePushL(file); |
|
1570 User::LeaveIfError(file.Replace(iFs, fileNamePtr, EFileWrite)); |
|
1571 |
|
1572 TPtrC8 ptr8 ( (TUint8*) tPtr.Ptr(), tPtr.Size() ); |
|
1573 file.Write ( ptr8 ); |
|
1574 file.Close(); |
|
1575 CleanupStack::PopAndDestroy(1); //file |
|
1576 CleanupStack::PopAndDestroy(serverFileBuf); |
|
1577 } |
|
1578 |
|
1579 CleanupStack::PopAndDestroy(policyFilePath); |
|
1580 CleanupStack::PopAndDestroy(policyFileNameBuf); |
|
1581 CleanupStack::PopAndDestroy(serverNameBuf); |
|
1582 CleanupStack::PopAndDestroy(serverUrlBuf); |
|
1583 CleanupStack::PopAndDestroy(policyServerSettingsFileName); |
|
1584 } |
|
1585 |
|
1586 } |
1157 } |
1587 /***/ |
1158 /***/ |