84 |
84 |
85 CFSKeyStoreClient::CFSKeyStoreClient(TInt aUID, MCTToken& aToken, RFileStoreClientSession& aClient) |
85 CFSKeyStoreClient::CFSKeyStoreClient(TInt aUID, MCTToken& aToken, RFileStoreClientSession& aClient) |
86 : CFSClient(aUID, aToken, aClient), |
86 : CFSClient(aUID, aToken, aClient), |
87 // Reference count starts at one as we're always created and returned by a GetInterface() call on the token |
87 // Reference count starts at one as we're always created and returned by a GetInterface() call on the token |
88 iRefCount(1) |
88 iRefCount(1) |
89 #ifdef SYMBIAN_AUTH_SERVER |
|
90 ,iUseNewKeyServer(EFalse) |
|
91 #endif // SYMBIAN_AUTH_SERVER |
|
92 { |
89 { |
93 LOG(_L("CFSKeyStoreClient::CFSKeyStoreClient: keystore client interface created")); |
90 LOG(_L("CFSKeyStoreClient::CFSKeyStoreClient: keystore client interface created")); |
94 } |
91 } |
95 |
92 |
96 void CFSKeyStoreClient::ConstructL() |
93 void CFSKeyStoreClient::ConstructL() |
97 { |
94 { |
98 CActiveScheduler::Add(this); |
95 CActiveScheduler::Add(this); |
99 |
|
100 #ifdef SYMBIAN_AUTH_SERVER |
|
101 TPckg<TBool> idNewKeyServer(iUseNewKeyServer); |
|
102 iClient.SendRequest(EUseNewKeyServer, TIpcArgs(0,&idNewKeyServer)); |
|
103 |
|
104 if(iUseNewKeyServer == EFalse) |
|
105 #endif // SYMBIAN_AUTH_SERVER |
|
106 { |
96 { |
107 iAuthObject = CKeyStoreAuthObject::NewL(*this); |
97 iAuthObject = CKeyStoreAuthObject::NewL(*this); |
108 iAuthObject->AddRef(); |
98 iAuthObject->AddRef(); |
109 } |
99 } |
110 |
100 |
372 } |
354 } |
373 |
355 |
374 void CFSKeyStoreClient::DoListL(const TCTKeyAttributeFilter& aFilter, MKeyInfoArray& aOut) |
356 void CFSKeyStoreClient::DoListL(const TCTKeyAttributeFilter& aFilter, MKeyInfoArray& aOut) |
375 { |
357 { |
376 TInt startOfNew = aOut.Count(); |
358 TInt startOfNew = aOut.Count(); |
377 #ifdef SYMBIAN_AUTH_SERVER |
|
378 if(iUseNewKeyServer == EFalse) |
|
379 { |
|
380 #endif // SYMBIAN_AUTH_SERVER |
|
381 ASSERT(iAuthObject); |
359 ASSERT(iAuthObject); |
382 #ifdef SYMBIAN_AUTH_SERVER |
|
383 } |
|
384 #endif // SYMBIAN_AUTH_SERVER |
|
385 |
360 |
386 TPckg<TCTKeyAttributeFilter> filterPckg(aFilter); |
361 TPckg<TCTKeyAttributeFilter> filterPckg(aFilter); |
387 SendSyncRequestAndHandleOverflowL(EListKeys, KInitialBufSizeList, TIpcArgs(&filterPckg, 0, &iRequestPtr)); |
362 SendSyncRequestAndHandleOverflowL(EListKeys, KInitialBufSizeList, TIpcArgs(&filterPckg, 0, &iRequestPtr)); |
388 |
363 |
389 CleanupClosePushL(aOut); |
364 CleanupClosePushL(aOut); |
390 TokenDataMarshaller::ReadL(iRequestPtr, iToken, aOut); |
365 TokenDataMarshaller::ReadL(iRequestPtr, iToken, aOut); |
391 #ifdef SYMBIAN_AUTH_SERVER |
|
392 if(iUseNewKeyServer == EFalse) |
|
393 { |
|
394 #endif //SYMBIAN_AUTH_SERVER |
|
395 for (TInt index = startOfNew ; index < aOut.Count() ; ++index) |
366 for (TInt index = startOfNew ; index < aOut.Count() ; ++index) |
396 { |
367 { |
397 iAuthObject->AddRef(); |
368 iAuthObject->AddRef(); |
398 LOG1(_L("CFSKeyStoreClient::DoListL: adding keyinfo %08x."), aOut[index]); |
369 LOG1(_L("CFSKeyStoreClient::DoListL: adding keyinfo %08x."), aOut[index]); |
399 aOut[index]->SetProtector(*iAuthObject); |
370 aOut[index]->SetProtector(*iAuthObject); |
400 } |
371 } |
401 #ifdef SYMBIAN_AUTH_SERVER |
|
402 } |
|
403 #endif // SYMBIAN_AUTH_SERVER |
|
404 CleanupStack::Pop(&aOut); |
372 CleanupStack::Pop(&aOut); |
405 } |
373 } |
406 |
374 |
407 void CFSKeyStoreClient::CancelList() |
375 void CFSKeyStoreClient::CancelList() |
408 { |
376 { |
1058 // synchronous, nothing to do |
1026 // synchronous, nothing to do |
1059 } |
1027 } |
1060 |
1028 |
1061 void CFSKeyStoreClient::SetPassphraseTimeout(TInt aTimeout, TRequestStatus& aStatus) |
1029 void CFSKeyStoreClient::SetPassphraseTimeout(TInt aTimeout, TRequestStatus& aStatus) |
1062 { |
1030 { |
1063 #ifdef SYMBIAN_AUTH_SERVER |
|
1064 if(iUseNewKeyServer) |
|
1065 { |
|
1066 TRequestStatus* stat = &aStatus; |
|
1067 User::RequestComplete(stat, KErrNotSupported); |
|
1068 return; |
|
1069 } |
|
1070 #endif // SYMBIAN_AUTH_SERVER |
|
1071 SetTimeout(aTimeout, aStatus); |
1031 SetTimeout(aTimeout, aStatus); |
1072 } |
1032 } |
1073 |
1033 |
1074 void CFSKeyStoreClient::CancelSetPassphraseTimeout() |
1034 void CFSKeyStoreClient::CancelSetPassphraseTimeout() |
1075 { |
1035 { |
1076 // No point cancelling, not asynchronous |
1036 // No point cancelling, not asynchronous |
1077 } |
1037 } |
1078 |
1038 |
1079 void CFSKeyStoreClient::Relock(TRequestStatus& aStatus) |
1039 void CFSKeyStoreClient::Relock(TRequestStatus& aStatus) |
1080 { |
1040 { |
1081 #ifdef SYMBIAN_AUTH_SERVER |
|
1082 if(iUseNewKeyServer) |
|
1083 { |
|
1084 TRequestStatus* stat = &aStatus; |
|
1085 User::RequestComplete(stat, KErrNotSupported); |
|
1086 return; |
|
1087 } |
|
1088 #endif // SYMBIAN_AUTH_SERVER |
|
1089 TInt err = iClient.SendRequest(ERelock, TIpcArgs()); |
1041 TInt err = iClient.SendRequest(ERelock, TIpcArgs()); |
1090 TRequestStatus* status = &aStatus; |
1042 TRequestStatus* status = &aStatus; |
1091 User::RequestComplete(status, err); |
1043 User::RequestComplete(status, err); |
1092 } |
1044 } |
1093 |
1045 |
1111 keyInfo.SetHandle(update.iReference); |
1063 keyInfo.SetHandle(update.iReference); |
1112 keyInfo.SetIdentifier(update.iId); |
1064 keyInfo.SetIdentifier(update.iId); |
1113 // Set size and algorithm - only strictly necessary for import |
1065 // Set size and algorithm - only strictly necessary for import |
1114 keyInfo.SetSize(update.iSize); |
1066 keyInfo.SetSize(update.iSize); |
1115 keyInfo.SetAlgorithm(update.iAlgorithm); |
1067 keyInfo.SetAlgorithm(update.iAlgorithm); |
1116 #ifdef SYMBIAN_AUTH_SERVER |
|
1117 if(iUseNewKeyServer == EFalse) |
|
1118 { |
|
1119 ASSERT(iAuthObject); |
|
1120 iAuthObject->AddRef(); |
|
1121 keyInfo.SetProtector(*iAuthObject); |
|
1122 } |
|
1123 #endif // SYMBIAN_AUTH_SERVER |
|
1124 LOG_DEC_INDENT(); |
1068 LOG_DEC_INDENT(); |
1125 } |
1069 } |
1126 |
1070 |
1127 // Implementation of auth object functionality |
1071 // Implementation of auth object functionality |
1128 |
1072 |
1129 void CFSKeyStoreClient::ListProtectedObjects(RMPointerArray<MCTTokenObject>& aObjects, TRequestStatus& aStatus) |
1073 void CFSKeyStoreClient::ListProtectedObjects(RMPointerArray<MCTTokenObject>& aObjects, TRequestStatus& aStatus) |
1130 { |
1074 { |
1131 #ifdef SYMBIAN_AUTH_SERVER |
|
1132 if(iUseNewKeyServer) |
|
1133 { |
|
1134 TRequestStatus* stat = &aStatus; |
|
1135 User::RequestComplete(stat, KErrNotSupported); |
|
1136 return; |
|
1137 } |
|
1138 #endif //SYMBIAN_AUTH_SERVER |
|
1139 TCTKeyAttributeFilter filter; |
1075 TCTKeyAttributeFilter filter; |
1140 filter.iPolicyFilter = TCTKeyAttributeFilter::EUsableOrManageableKeys; |
1076 filter.iPolicyFilter = TCTKeyAttributeFilter::EUsableOrManageableKeys; |
1141 TKeyInfoArray<MCTTokenObject> array(aObjects); |
1077 TKeyInfoArray<MCTTokenObject> array(aObjects); |
1142 TRAPD(err, DoListL(filter, array)); |
1078 TRAPD(err, DoListL(filter, array)); |
1143 FreeRequestBuffer(); |
1079 FreeRequestBuffer(); |
1145 User::RequestComplete(status, err); |
1081 User::RequestComplete(status, err); |
1146 } |
1082 } |
1147 |
1083 |
1148 void CFSKeyStoreClient::ChangeReferenceData(TRequestStatus &aStatus) |
1084 void CFSKeyStoreClient::ChangeReferenceData(TRequestStatus &aStatus) |
1149 { |
1085 { |
1150 #ifdef SYMBIAN_AUTH_SERVER |
|
1151 if(iUseNewKeyServer) |
|
1152 { |
|
1153 TRequestStatus* stat = &aStatus; |
|
1154 User::RequestComplete(stat, KErrNotSupported); |
|
1155 return; |
|
1156 } |
|
1157 #endif //SYMBIAN_AUTH_SERVER |
|
1158 iCurrentRequest(EChangePassphrase, &aStatus); |
1086 iCurrentRequest(EChangePassphrase, &aStatus); |
1159 SetActive(); |
1087 SetActive(); |
1160 iClient.SendAsyncRequest(EChangePassphrase, TIpcArgs(), &iStatus); |
1088 iClient.SendAsyncRequest(EChangePassphrase, TIpcArgs(), &iStatus); |
1161 } |
1089 } |
1162 |
1090 |
1163 void CFSKeyStoreClient::CancelChangeReferenceData() |
1091 void CFSKeyStoreClient::CancelChangeReferenceData() |
1164 { |
1092 { |
1165 #ifdef SYMBIAN_AUTH_SERVER |
|
1166 if(iUseNewKeyServer) |
|
1167 { |
|
1168 return; |
|
1169 } |
|
1170 #endif //SYMBIAN_AUTH_SERVER |
|
1171 if (iCurrentRequest.OutstandingRequest() == EChangePassphrase) |
1093 if (iCurrentRequest.OutstandingRequest() == EChangePassphrase) |
1172 { |
1094 { |
1173 Cancel(); |
1095 Cancel(); |
1174 } |
1096 } |
1175 } |
1097 } |
1176 |
1098 |
1177 TUint32 CFSKeyStoreClient::AuthStatus() const |
1099 TUint32 CFSKeyStoreClient::AuthStatus() const |
1178 { |
1100 { |
1179 #ifdef SYMBIAN_AUTH_SERVER |
|
1180 if(iUseNewKeyServer) |
|
1181 { |
|
1182 return 0; |
|
1183 } |
|
1184 #endif // SYMBIAN_AUTH_SERVER |
|
1185 |
|
1186 return EEnabled | EUnblockDisabled; |
1101 return EEnabled | EUnblockDisabled; |
1187 } |
1102 } |
1188 |
1103 |
1189 void CFSKeyStoreClient::AuthOpen(TRequestStatus& aStatus) |
1104 void CFSKeyStoreClient::AuthOpen(TRequestStatus& aStatus) |
1190 { |
1105 { |
1191 #ifdef SYMBIAN_AUTH_SERVER |
|
1192 if(iUseNewKeyServer) |
|
1193 { |
|
1194 TRequestStatus* stat = &aStatus; |
|
1195 User::RequestComplete(stat, KErrNotSupported); |
|
1196 return; |
|
1197 } |
|
1198 #endif // SYMBIAN_AUTH_SERVER |
|
1199 iCurrentRequest(EAuthOpen, &aStatus); |
1106 iCurrentRequest(EAuthOpen, &aStatus); |
1200 SetActive(); |
1107 SetActive(); |
1201 iClient.SendAsyncRequest(EAuthOpen, TIpcArgs(), &iStatus); |
1108 iClient.SendAsyncRequest(EAuthOpen, TIpcArgs(), &iStatus); |
1202 } |
1109 } |
1203 |
1110 |
1204 void CFSKeyStoreClient::CancelAuthOpen() |
1111 void CFSKeyStoreClient::CancelAuthOpen() |
1205 { |
1112 { |
1206 #ifdef SYMBIAN_AUTH_SERVER |
|
1207 if(iUseNewKeyServer) |
|
1208 { |
|
1209 return; |
|
1210 } |
|
1211 #endif // SYMBIAN_AUTH_SERVER |
|
1212 if (iCurrentRequest.OutstandingRequest() == EAuthOpen) |
1113 if (iCurrentRequest.OutstandingRequest() == EAuthOpen) |
1213 { |
1114 { |
1214 Cancel(); |
1115 Cancel(); |
1215 } |
1116 } |
1216 } |
1117 } |
1217 |
1118 |
1218 void CFSKeyStoreClient::AuthClose(TRequestStatus& aStatus) |
1119 void CFSKeyStoreClient::AuthClose(TRequestStatus& aStatus) |
1219 { |
1120 { |
1220 #ifdef SYMBIAN_AUTH_SERVER |
|
1221 if(iUseNewKeyServer) |
|
1222 { |
|
1223 TRequestStatus* stat = &aStatus; |
|
1224 User::RequestComplete(stat, KErrNotSupported); |
|
1225 return; |
|
1226 } |
|
1227 #endif //SYMBIAN_AUTH_SERVER |
|
1228 TInt err = iClient.SendRequest(EAuthClose, TIpcArgs()); |
1121 TInt err = iClient.SendRequest(EAuthClose, TIpcArgs()); |
1229 TRequestStatus* status = &aStatus; |
1122 TRequestStatus* status = &aStatus; |
1230 User::RequestComplete(status, err); |
1123 User::RequestComplete(status, err); |
1231 } |
1124 } |
1232 |
1125 |
1233 void CFSKeyStoreClient::TimeRemaining(TInt& aTime, TRequestStatus& aStatus) |
1126 void CFSKeyStoreClient::TimeRemaining(TInt& aTime, TRequestStatus& aStatus) |
1234 { |
1127 { |
1235 #ifdef SYMBIAN_AUTH_SERVER |
|
1236 if(iUseNewKeyServer) |
|
1237 { |
|
1238 TRequestStatus* stat = &aStatus; |
|
1239 User::RequestComplete(stat, KErrNotSupported); |
|
1240 return; |
|
1241 } |
|
1242 #endif //SYMBIAN_AUTH_SERVER |
|
1243 TInt result = iClient.SendRequest(EAuthTimeRemaining, TIpcArgs()); |
1128 TInt result = iClient.SendRequest(EAuthTimeRemaining, TIpcArgs()); |
1244 if (result >= 0) |
1129 if (result >= 0) |
1245 { |
1130 { |
1246 aTime = result; |
1131 aTime = result; |
1247 result = KErrNone; |
1132 result = KErrNone; |
1250 User::RequestComplete(status, result); |
1135 User::RequestComplete(status, result); |
1251 } |
1136 } |
1252 |
1137 |
1253 void CFSKeyStoreClient::SetTimeout(TInt aTime, TRequestStatus& aStatus) |
1138 void CFSKeyStoreClient::SetTimeout(TInt aTime, TRequestStatus& aStatus) |
1254 { |
1139 { |
1255 #ifdef SYMBIAN_AUTH_SERVER |
|
1256 if(iUseNewKeyServer) |
|
1257 { |
|
1258 TRequestStatus* stat = &aStatus; |
|
1259 User::RequestComplete(stat, KErrNotSupported); |
|
1260 return; |
|
1261 } |
|
1262 #endif //SYMBIAN_AUTH_SERVER |
|
1263 TInt err = iClient.SendRequest(ESetTimeout, TIpcArgs(0, aTime)); |
1140 TInt err = iClient.SendRequest(ESetTimeout, TIpcArgs(0, aTime)); |
1264 TRequestStatus* status = &aStatus; |
1141 TRequestStatus* status = &aStatus; |
1265 User::RequestComplete(status, err); |
1142 User::RequestComplete(status, err); |
1266 } |
1143 } |
1267 |
1144 |
1268 void CFSKeyStoreClient::Timeout(TInt& aTime, TRequestStatus& aStatus) |
1145 void CFSKeyStoreClient::Timeout(TInt& aTime, TRequestStatus& aStatus) |
1269 { |
1146 { |
1270 #ifdef SYMBIAN_AUTH_SERVER |
|
1271 if(iUseNewKeyServer) |
|
1272 { |
|
1273 TRequestStatus* stat = &aStatus; |
|
1274 User::RequestComplete(stat, KErrNotSupported); |
|
1275 return; |
|
1276 } |
|
1277 #endif //SYMBIAN_AUTH_SERVER |
|
1278 TInt result = iClient.SendRequest(EGetTimeout, TIpcArgs()); |
1147 TInt result = iClient.SendRequest(EGetTimeout, TIpcArgs()); |
1279 if (result >= 0) |
1148 if (result >= 0) |
1280 { |
1149 { |
1281 aTime = result; |
1150 aTime = result; |
1282 result = KErrNone; |
1151 result = KErrNone; |
1283 } |
1152 } |
1284 TRequestStatus* status = &aStatus; |
1153 TRequestStatus* status = &aStatus; |
1285 User::RequestComplete(status, result); |
1154 User::RequestComplete(status, result); |
1286 } |
1155 } |
1287 |
1156 |
1288 #ifdef SYMBIAN_AUTH_SERVER |
1157 |
1289 |
|
1290 void CFSKeyStoreClient::CreateKey( const TDesC& aAuthenticationString, |
|
1291 TInt aFreshness, |
|
1292 CCTKeyInfo*& aReturnedKey, |
|
1293 TRequestStatus& aStatus ) |
|
1294 { |
|
1295 LOG(_L("CFSKeyStoreClient::CreateKey: create key (starting)")); |
|
1296 #ifdef SYMBIAN_AUTH_SERVER |
|
1297 if(iUseNewKeyServer == EFalse) |
|
1298 { |
|
1299 TRequestStatus* stat = &aStatus; |
|
1300 User::RequestComplete(stat, KErrNotSupported); |
|
1301 return; |
|
1302 } |
|
1303 #endif //SYMBIAN_AUTH_SERVER |
|
1304 // [in, out] CCTKeyInfo, caller fills with data required to create the key, |
|
1305 // If request succeeds, iId and iHandle members are filled in by server |
|
1306 |
|
1307 TInt r = MarshalKeyInfo(*aReturnedKey); |
|
1308 if (KErrNone!=r) |
|
1309 { |
|
1310 TRequestStatus* stat = &aStatus; |
|
1311 User::RequestComplete(stat, r); |
|
1312 return; |
|
1313 } |
|
1314 |
|
1315 // Store CCTKeyInfo to write into later (server will put extra data into it) |
|
1316 iClientPtr.iKeyInfo = &aReturnedKey; |
|
1317 SetActive(); |
|
1318 iCurrentRequest(ECreateUserKey, &aStatus); |
|
1319 |
|
1320 iClient.SendAsyncRequest(ECreateUserKey, TIpcArgs(0, &iRequestPtr, &aAuthenticationString, aFreshness), &iStatus); |
|
1321 |
|
1322 } |
|
1323 |
|
1324 void CFSKeyStoreClient::ImportKey( const TDesC8& aKey, |
|
1325 const TDesC& aAuthenticationString, |
|
1326 TInt aFreshness, CCTKeyInfo*& aReturnedKey, |
|
1327 TRequestStatus& aStatus ) |
|
1328 { |
|
1329 #ifdef SYMBIAN_AUTH_SERVER |
|
1330 if(iUseNewKeyServer == EFalse) |
|
1331 { |
|
1332 TRequestStatus* stat = &aStatus; |
|
1333 User::RequestComplete(stat, KErrNotSupported); |
|
1334 return; |
|
1335 } |
|
1336 #endif //SYMBIAN_AUTH_SERVER |
|
1337 DoImportUserKey(EImportUserKey, aKey, aReturnedKey, aAuthenticationString, aFreshness, aStatus); |
|
1338 } |
|
1339 |
|
1340 |
|
1341 void CFSKeyStoreClient::ImportEncryptedKey(const TDesC8& aKey, |
|
1342 const TDesC& aAuthenticationString, |
|
1343 TInt aFreshness, CCTKeyInfo*& aReturnedKey, |
|
1344 TRequestStatus& aStatus ) |
|
1345 { |
|
1346 #ifdef SYMBIAN_AUTH_SERVER |
|
1347 if(iUseNewKeyServer == EFalse) |
|
1348 { |
|
1349 TRequestStatus* stat = &aStatus; |
|
1350 User::RequestComplete(stat, KErrNotSupported); |
|
1351 return; |
|
1352 } |
|
1353 #endif //SYMBIAN_AUTH_SERVER |
|
1354 DoImportUserKey(EImportEncryptedUserKey, aKey, aReturnedKey, aAuthenticationString, aFreshness, aStatus); |
|
1355 |
|
1356 } |
|
1357 |
|
1358 void CFSKeyStoreClient::SetAuthenticationPolicy( |
|
1359 const TCTTokenObjectHandle aHandle, |
|
1360 const TDesC& aAuthenticationString, |
|
1361 TInt aFreshness, |
|
1362 TRequestStatus& aStatus) |
|
1363 { |
|
1364 #ifdef SYMBIAN_AUTH_SERVER |
|
1365 if(iUseNewKeyServer == EFalse) |
|
1366 { |
|
1367 TRequestStatus* stat = &aStatus; |
|
1368 User::RequestComplete(stat, KErrNotSupported); |
|
1369 return; |
|
1370 } |
|
1371 iCurrentRequest(ESetAuthenticationPolicy, &aStatus); |
|
1372 SetActive(); |
|
1373 iClient.SendAsyncRequest(ESetAuthenticationPolicy, TIpcArgs(aHandle.iObjectId, &aAuthenticationString, aFreshness), &iStatus); |
|
1374 |
|
1375 #endif //SYMBIAN_AUTH_SERVER |
|
1376 } |
|
1377 |
|
1378 void CFSKeyStoreClient::GetAuthenticationPolicy( const TCTTokenObjectHandle aHandle, |
|
1379 HBufC*& aAuthenticationString, |
|
1380 TInt& aFreshness, |
|
1381 TRequestStatus& aStatus) |
|
1382 { |
|
1383 #ifdef SYMBIAN_AUTH_SERVER |
|
1384 if(iUseNewKeyServer == EFalse) |
|
1385 { |
|
1386 TRequestStatus* stat = &aStatus; |
|
1387 User::RequestComplete(stat, KErrNotSupported); |
|
1388 return; |
|
1389 } |
|
1390 iAuthExpression = aAuthenticationString; |
|
1391 iFreshness = aFreshness; |
|
1392 TPckg<TInt> freshness(aFreshness); |
|
1393 TPtr authPtr = iAuthExpression->Des(); |
|
1394 TInt err = iClient.SendRequest(EGetAuthenticationPolicy, TIpcArgs(aHandle.iObjectId, &authPtr, &freshness)); |
|
1395 TRequestStatus* status = &aStatus; |
|
1396 User::RequestComplete(status, err); |
|
1397 |
|
1398 #endif //SYMBIAN_AUTH_SERVER |
|
1399 |
|
1400 |
|
1401 } |
|
1402 #endif // SYMBIAN_AUTH_SERVER |
|