1// ====================================================================== 2// File: KCAPI_Keychain.cpp 3// 4// Operation classes for core KC APIs: 5// - KCMakeKCRefFromFSRef 6// - KCMakeKCRefFromFSSpec 7// - KCMakeKCRefFromAlias 8// - KCMakeAliasFromKCRef 9// - KCReleaseKeychain 10// - KCUnlockNoUI 11// - KCUnlock 12// - KCUnlockWithInfo 13// - KCLock 14// - KCLockNoUI 15// - KCGetDefaultKeychain 16// - KCSetDefaultKeychain 17// - KCCreateKeychain 18// - KCCreateKeychainNoUI 19// - KCGetStatus 20// - KCChangeSettingsNoUI 21// - KCGetKeychain 22// - KCGetKeychainName 23// - KCChangeSettings 24// - KCCountKeychains 25// - KCGetIndKeychain 26// - KCAddCallback 27// - KCRemoveCallback 28// - KCSetInteractionAllowed 29// - KCIsInteractionAllowed 30// 31// Copyright: Copyright (c) 2000,2003 Apple Computer, Inc. All Rights Reserved. 32// 33// Change History (most recent first): 34// 35// <1> 2/25/00 em Created. 36// ====================================================================== 37#include "KCAPI_Keychain.h" 38 39#if TARGET_RT_MAC_MACHO 40 #include <OSServices/KeychainCorePriv.h> 41#endif 42 43#include <Carbon/Carbon.h> 44#undef check 45UInt32 COp_KCAddCallback::sCounter[] = {0,0,0,0,0,0,0,0,0,0,0}; 46 47// ��������������������������������������������������������������������������� 48// � COp_KCMakeKCRefFromFSRef 49// ��������������������������������������������������������������������������� 50COp_KCMakeKCRefFromFSRef::COp_KCMakeKCRefFromFSRef() 51 :mFSRef("FSRef") 52{ 53 AddParam(mFSRef); 54} 55// ��������������������������������������������������������������������������� 56// � Operate 57// ��������������������������������������������������������������������������� 58OSStatus 59COp_KCMakeKCRefFromFSRef::Operate() 60{ 61 throw("KCMakeKCRefFromFSRef is not implemented"); 62 return(mStatus); 63} 64#pragma mark - 65// ��������������������������������������������������������������������������� 66// � COp_KCMakeKCRefFromFSSpec 67// ��������������������������������������������������������������������������� 68COp_KCMakeKCRefFromFSSpec::COp_KCMakeKCRefFromFSSpec() 69 :mKeychainFile("KeychainFile") 70{ 71 AddParam(mKeychainFile); 72 AddResult(mKeychainIndex); 73} 74// ��������������������������������������������������������������������������� 75// � Operate 76// ��������������������������������������������������������������������������� 77OSStatus 78COp_KCMakeKCRefFromFSSpec::Operate() 79{ 80 KCRef aKeychain = NULL; 81 82 mStatus = ::KCMakeKCRefFromFSSpec( 83 (FSSpec*)mKeychainFile, 84 &aKeychain); 85 86 AddKeychain(aKeychain); 87 return(mStatus); 88} 89#pragma mark - 90// ��������������������������������������������������������������������������� 91// � COp_KCMakeKCRefFromAlias 92// ��������������������������������������������������������������������������� 93COp_KCMakeKCRefFromAlias::COp_KCMakeKCRefFromAlias() 94{ 95 AddParam(mAliasIndex); 96 AddResult(mKeychainIndex); 97} 98// ��������������������������������������������������������������������������� 99// � Operate 100// ��������������������������������������������������������������������������� 101OSStatus 102COp_KCMakeKCRefFromAlias::Operate() 103{ 104 KCRef aKeychain = NULL; 105 AliasHandle alias = GetAlias(); 106 107 mStatus = ::KCMakeKCRefFromAlias(alias, &aKeychain); 108 AddKeychain(aKeychain); 109 return(mStatus); 110} 111#pragma mark - 112// ��������������������������������������������������������������������������� 113// � COp_KCMakeAliasFromKCRef 114// ��������������������������������������������������������������������������� 115COp_KCMakeAliasFromKCRef::COp_KCMakeAliasFromKCRef() 116{ 117 AddParam(mKeychainIndex); 118 AddResult(mAliasIndex); 119} 120// ��������������������������������������������������������������������������� 121// � Operate 122// ��������������������������������������������������������������������������� 123OSStatus 124COp_KCMakeAliasFromKCRef::Operate() 125{ 126 AliasHandle alias = GetAlias(); 127 mStatus = ::KCMakeAliasFromKCRef(GetKeychain(), (AliasHandle*)&alias); 128 AddAlias(alias); 129 return(mStatus); 130} 131#pragma mark - 132// ��������������������������������������������������������������������������� 133// � COp_KCReleaseKeychain 134// ��������������������������������������������������������������������������� 135COp_KCReleaseKeychain::COp_KCReleaseKeychain() 136{ 137 AddParam(mKeychainIndex); 138} 139// ��������������������������������������������������������������������������� 140// � Operate 141// ��������������������������������������������������������������������������� 142OSStatus 143COp_KCReleaseKeychain::Operate() 144{ 145 KCRef aKeychain = GetKeychain(); 146 mStatus = ::KCReleaseKeychain(&aKeychain); 147 return(mStatus); 148} 149#pragma mark - 150// ��������������������������������������������������������������������������� 151// � COp_KCLogout 152// ��������������������������������������������������������������������������� 153COp_KCLogout::COp_KCLogout() 154{ 155} 156 157OSStatus 158COp_KCLogout::Operate() 159{ 160 mStatus = ::KCLogout(); 161 162 return(mStatus); 163} 164// ��������������������������������������������������������������������������� 165// � COp_KCLogin 166// ��������������������������������������������������������������������������� 167COp_KCLogin::COp_KCLogin() 168 :mName("Name"), 169 mPassword("Password") 170{ 171 AddParam(mName); 172 AddParam(mPassword); 173} 174 175OSStatus 176COp_KCLogin::Operate() 177{ 178 mStatus = ::KCLogin( (StringPtr)mName, (StringPtr)mPassword ); 179 180 return(mStatus); 181} 182 183// ��������������������������������������������������������������������������� 184// � COp_KCChangeLoginPassword 185// ��������������������������������������������������������������������������� 186COp_KCChangeLoginPassword::COp_KCChangeLoginPassword() 187 :mOldPassword("OldPassword"), 188 mNewPassword("NewPassword") 189{ 190 AddParam(mOldPassword); 191 AddParam(mNewPassword); 192} 193 194OSStatus 195COp_KCChangeLoginPassword::Operate() 196{ 197 mStatus = ::KCChangeLoginPassword( (StringPtr)mOldPassword, (StringPtr)mNewPassword ); 198 199 return(mStatus); 200} 201 202// ��������������������������������������������������������������������������� 203// � COp_KCUnlockNoUI 204// ��������������������������������������������������������������������������� 205COp_KCUnlockNoUI::COp_KCUnlockNoUI() 206 :mPassword("Password") 207{ 208 AddParam(mKeychainIndex); 209 AddParam(mPassword); 210} 211// ��������������������������������������������������������������������������� 212// � Operate 213// ��������������������������������������������������������������������������� 214OSStatus 215COp_KCUnlockNoUI::Operate() 216{ 217//#if TARGET_RT_MAC_MACHO 218//%%%������� 219 KCRef aKeychain = GetKeychain(); 220 mStatus = ::KCUnlockNoUI( aKeychain, (StringPtr)mPassword); 221// throw("KCUnlockNoUI not implemented"); 222//#else 223// throw("KCUnlockNoUI not implemented"); 224//#endif 225 return(mStatus); 226} 227#pragma mark - 228// ��������������������������������������������������������������������������� 229// � COp_KCUnlock 230// ��������������������������������������������������������������������������� 231COp_KCUnlock::COp_KCUnlock() 232 :mPassword("Password") 233{ 234 AddParam(mKeychainIndex); 235 AddParam(mPassword); 236} 237// ��������������������������������������������������������������������������� 238// � Operate 239// ��������������������������������������������������������������������������� 240OSStatus 241COp_KCUnlock::Operate() 242{ 243 mStatus = ::KCUnlock(GetKeychain(), (StringPtr)mPassword); 244 return(mStatus); 245} 246#pragma mark - 247// ��������������������������������������������������������������������������� 248// � COp_KCUnlockWithInfo 249// ��������������������������������������������������������������������������� 250COp_KCUnlockWithInfo::COp_KCUnlockWithInfo() 251 :mPassword("Password"), mMessage("Mesage") 252{ 253 AddParam(mKeychainIndex); 254 AddParam(mPassword); 255 AddParam(mMessage); 256} 257// ��������������������������������������������������������������������������� 258// � Operate 259// ��������������������������������������������������������������������������� 260OSStatus 261COp_KCUnlockWithInfo::Operate() 262{ 263#if 0 //TARGET_RT_MAC_MACHO 264 mStatus = ::KCUnlockWithInfo(GetKeychain(), (StringPtr)mPassword, (StringPtr)mMessage); 265#else 266 return unimpErr; 267 //throw("KCUnlockWithInfo is not implemented"); 268#endif 269 return(mStatus); 270} 271#pragma mark - 272// ��������������������������������������������������������������������������� 273// � COp_KCLock 274// ��������������������������������������������������������������������������� 275COp_KCLock::COp_KCLock() 276{ 277 AddParam(mKeychainIndex); 278} 279// ��������������������������������������������������������������������������� 280// � Operate 281// ��������������������������������������������������������������������������� 282OSStatus 283COp_KCLock::Operate() 284{ 285 mStatus = ::KCLock(GetKeychain()); 286 return(mStatus); 287} 288#pragma mark - 289// ��������������������������������������������������������������������������� 290// � COp_KCLockNoUI 291// ��������������������������������������������������������������������������� 292/* 293COp_KCLockNoUI::COp_KCLockNoUI() 294{ 295 AddParam(mKeychainIndex); 296} 297*/ 298// ��������������������������������������������������������������������������� 299// � Operate 300// ��������������������������������������������������������������������������� 301/* 302OSStatus 303COp_KCLockNoUI::Operate() 304{ 305#if TARGET_RT_MAC_MACHO 306 mStatus = ::KCLockNoUI(GetKeychain()); 307#else 308 throw("KCLockNoUI not implemented"); 309#endif 310 return(mStatus); 311} 312#pragma mark - 313*/ 314// ��������������������������������������������������������������������������� 315// � COp_KCGetDefaultKeychain 316// ��������������������������������������������������������������������������� 317COp_KCGetDefaultKeychain::COp_KCGetDefaultKeychain() 318{ 319 AddResult(mKeychainIndex); 320} 321// ��������������������������������������������������������������������������� 322// � Operate 323// ��������������������������������������������������������������������������� 324OSStatus 325COp_KCGetDefaultKeychain::Operate() 326{ 327 KCRef aKeychain = NULL; 328 mStatus = ::KCGetDefaultKeychain(&aKeychain); 329 AddKeychain(aKeychain); 330 return(mStatus); 331} 332#pragma mark - 333// ��������������������������������������������������������������������������� 334// � COp_KCSetDefaultKeychain 335// ��������������������������������������������������������������������������� 336COp_KCSetDefaultKeychain::COp_KCSetDefaultKeychain() 337{ 338 AddParam(mKeychainIndex); 339} 340// ��������������������������������������������������������������������������� 341// � Operate 342// ��������������������������������������������������������������������������� 343OSStatus 344COp_KCSetDefaultKeychain::Operate() 345{ 346 mStatus = ::KCSetDefaultKeychain(GetKeychain()); 347 return(mStatus); 348} 349#pragma mark - 350// ��������������������������������������������������������������������������� 351// � COp_KCCreateKeychain 352// ��������������������������������������������������������������������������� 353COp_KCCreateKeychain::COp_KCCreateKeychain() 354 :mPassword("Password") 355{ 356 AddParam(mKeychainIndex); 357 AddParam(mPassword); 358 AddResult(mKeychainIndex); 359} 360// ��������������������������������������������������������������������������� 361// � Operate 362// ��������������������������������������������������������������������������� 363OSStatus 364COp_KCCreateKeychain::Operate() 365{ 366 KCRef aKeychain = GetKeychain(); 367 mStatus = ::KCCreateKeychain((StringPtr)mPassword, &aKeychain); 368 AddKeychain(aKeychain); 369 return(mStatus); 370} 371#pragma mark - 372// ��������������������������������������������������������������������������� 373// � COp_KCCreateKeychainNoUI 374// ��������������������������������������������������������������������������� 375COp_KCCreateKeychainNoUI::COp_KCCreateKeychainNoUI() 376 : mPassword("Password") 377{ 378 AddParam(mKeychainIndex); 379 AddParam(mPassword); 380} 381// ��������������������������������������������������������������������������� 382// � Operate 383// ��������������������������������������������������������������������������� 384OSStatus 385COp_KCCreateKeychainNoUI::Operate() 386{ 387//#if TARGET_RT_MAC_MACHO 388 389 KCRef aKeychain = GetKeychain(); 390 391 mStatus = ::KCCreateKeychainNoUI(aKeychain, (StringPtr)mPassword); 392//#else 393// throw("KCCreateKeychainNoUI not implemented"); 394//#endif 395 return(mStatus); 396} 397// ��������������������������������������������������������������������������� 398// � Callback 399// ��������������������������������������������������������������������������� 400OSStatus 401COp_KCCreateKeychainNoUI::Callback( 402 KCRef *outKeychain, 403 StringPtr *outPassword, 404 void *inContext) 405{ 406/* COp_KCCreateKeychainNoUI *thisObject = static_cast<COp_KCCreateKeychainNoUI*>(inContext); 407 if(thisObject == NULL) return -1; 408 409// FSSpec *aFileSpec = thisObject->GetKeychainFile(); 410 KCRef *aKeychain = thisObject->GetKeychainInCallback(); 411 StringPtr aPassword = thisObject->GetPassword(); 412 // OSStatus aStatus = ::KCMakeKCRefFromFSSpec(aFileSpec, aKeychain); 413 if(aStatus == noErr){ 414 *outKeychain = *aKeychain; 415 *outPassword = aPassword; 416 } 417 else{ 418 *outKeychain = NULL; 419 *outPassword = NULL; 420 } 421 422 return aStatus; 423*/ 424return noErr; 425} 426#pragma mark - 427// ��������������������������������������������������������������������������� 428// � COp_KCGetStatus 429// ��������������������������������������������������������������������������� 430COp_KCGetStatus::COp_KCGetStatus() 431 :mKeychainStatus("KeychainStatus") 432{ 433 AddParam(mKeychainIndex); 434 AddResult(mKeychainStatus); 435} 436// ��������������������������������������������������������������������������� 437// � Operate 438// ��������������������������������������������������������������������������� 439OSStatus 440COp_KCGetStatus::Operate() 441{ 442 mStatus = ::KCGetStatus( 443 GetKeychain(), 444 (UInt32*)mKeychainStatus); 445 return(mStatus); 446} 447#pragma mark - 448// ��������������������������������������������������������������������������� 449// � COp_KCChangeSettingsNoUI 450// ��������������������������������������������������������������������������� 451COp_KCChangeSettingsNoUI::COp_KCChangeSettingsNoUI() 452 :mLockOnSleep("LockOnSleep"), 453 mUseKCGetDataSound("UseKCGetDataSound"), 454 mUseKCGetDataAlert("UseKCGetDataAlert"), 455 mUseLockInterval("UseLockInterval"), 456 mLockInterval("LockInterval"), 457 mNewPassword("NewPassword"), 458 mOldPassword("OldPassword") 459{ 460 AddParam(mLockOnSleep); 461 AddParam(mUseKCGetDataSound); 462 AddParam(mUseKCGetDataAlert); 463 AddParam(mUseLockInterval); 464 AddParam(mLockInterval); 465 AddParam(mNewPassword); 466 AddParam(mOldPassword); 467 AddParam(mKeychainIndex); 468} 469 470// ��������������������������������������������������������������������������� 471// � Operate 472// ��������������������������������������������������������������������������� 473OSStatus 474COp_KCChangeSettingsNoUI::Operate() 475{ 476#if TARGET_RT_MAC_MACHO 477 478 mChangeSettingsInfo.lockOnSleep = (Boolean)mLockOnSleep; 479// mChangeSettingsInfo.useKCGetDataSound = (Boolean)mUseKCGetDataSound; 480// mChangeSettingsInfo.useKCGetDataAlert = (Boolean)mUseKCGetDataAlert; 481 mChangeSettingsInfo.useLockInterval = (Boolean)mUseLockInterval; 482 mChangeSettingsInfo.lockInterval = (UInt32)mLockInterval; 483// mChangeSettingsInfo.newPassword = (StringPtr)mNewPassword; 484// mChangeSettingsInfo.oldPassword = (StringPtr)mOldPassword; 485 mChangeSettingsInfo.keychain = GetKeychain(); 486 487// mStatus = ::KCChangeSettingsNoUI( 488// COp_KCChangeSettingsNoUI::Callback, 489// this); 490 throw("KCChangeSettingsNoUI not implemented"); 491#else 492 throw("KCChangeSettingsNoUI not implemented"); 493#endif 494 return(mStatus); 495} 496 497#if TARGET_RT_MAC_MACHO 498// ��������������������������������������������������������������������������� 499// � Callback 500// ��������������������������������������������������������������������������� 501OSStatus 502COp_KCChangeSettingsNoUI::Callback( 503 KCChangeSettingsInfo * outSettings, 504 void * inContext) 505{ 506 COp_KCChangeSettingsNoUI *thisObject = static_cast<COp_KCChangeSettingsNoUI*>(inContext); 507 if(thisObject == NULL) return -1; 508 509 // #2462430 - this should be : 510 // *outSettings = thisObject->GetSettingsInfoPtr(); 511 // where KCChangeSettingsInfo **outSettings 512 // 513 outSettings = thisObject->GetChangeSettingsInfoPtr(); 514 return noErr; 515} 516#endif 517 518#pragma mark - 519// ��������������������������������������������������������������������������� 520// � COp_KCGetKeychain 521// ��������������������������������������������������������������������������� 522COp_KCGetKeychain::COp_KCGetKeychain() 523{ 524 AddParam(mItemIndex); 525 AddResult(mKeychainIndex); 526} 527// ��������������������������������������������������������������������������� 528// � Operate 529// ��������������������������������������������������������������������������� 530OSStatus 531COp_KCGetKeychain::Operate() 532{ 533 KCRef aKeychain; 534 mStatus = ::KCGetKeychain( 535 GetItem(), 536 &aKeychain); 537 AddKeychain(aKeychain); 538 return(mStatus); 539} 540#pragma mark - 541// ��������������������������������������������������������������������������� 542// � COp_KCGetKeychainName 543// ��������������������������������������������������������������������������� 544COp_KCGetKeychainName::COp_KCGetKeychainName() 545 :mKeychainName("KeychainName") 546{ 547 AddParam(mKeychainIndex); 548 AddResult(mKeychainName); 549} 550// ��������������������������������������������������������������������������� 551// � Operate 552// ��������������������������������������������������������������������������� 553OSStatus 554COp_KCGetKeychainName::Operate() 555{ 556 mStatus = ::KCGetKeychainName( 557 GetKeychain(), 558 (StringPtr)mKeychainName); 559 return(mStatus); 560} 561#pragma mark - 562// ��������������������������������������������������������������������������� 563// � COp_KCChangeSettings 564// ��������������������������������������������������������������������������� 565COp_KCChangeSettings::COp_KCChangeSettings() 566{ 567 AddParam(mKeychainIndex); 568} 569// ��������������������������������������������������������������������������� 570// � Operate 571// ��������������������������������������������������������������������������� 572OSStatus 573COp_KCChangeSettings::Operate() 574{ 575 mStatus = ::KCChangeSettings(GetKeychain()); 576 return(mStatus); 577} 578#pragma mark - 579// ��������������������������������������������������������������������������� 580// � COp_KCCountKeychains 581// ��������������������������������������������������������������������������� 582COp_KCCountKeychains::COp_KCCountKeychains() 583 :mCount("Count") 584{ 585 AddResult(mCount); 586} 587// ��������������������������������������������������������������������������� 588// � Operate 589// ��������������������������������������������������������������������������� 590OSStatus 591COp_KCCountKeychains::Operate() 592{ 593 mStatus = noErr; 594 mCount = ::KCCountKeychains(); 595 return(mStatus); 596} 597#pragma mark - 598// ��������������������������������������������������������������������������� 599// � COp_KCGetIndKeychain 600// ��������������������������������������������������������������������������� 601COp_KCGetIndKeychain::COp_KCGetIndKeychain() 602 :mIndex("Index") 603{ 604 AddParam(mIndex); 605 AddResult(mKeychainIndex); 606} 607// ��������������������������������������������������������������������������� 608// � Operate 609// ��������������������������������������������������������������������������� 610OSStatus 611COp_KCGetIndKeychain::Operate() 612{ 613 KCRef aKeychain = NULL; 614 mStatus = ::KCGetIndKeychain(mIndex, &aKeychain); 615 AddKeychain(aKeychain); 616 return(mStatus); 617} 618#pragma mark - 619KCCallbackUPP COp_KCAddCallback::sCallbacks[] = 620 { NewKCCallbackUPP(COp_KCAddCallback::Callback0), 621 NewKCCallbackUPP(COp_KCAddCallback::Callback1), 622 NewKCCallbackUPP(COp_KCAddCallback::Callback2), 623 NewKCCallbackUPP(COp_KCAddCallback::Callback3), 624 NewKCCallbackUPP(COp_KCAddCallback::Callback4), 625 NewKCCallbackUPP(COp_KCAddCallback::Callback5), 626 NewKCCallbackUPP(COp_KCAddCallback::Callback6), 627 NewKCCallbackUPP(COp_KCAddCallback::Callback7), 628 NewKCCallbackUPP(COp_KCAddCallback::Callback8), 629 NewKCCallbackUPP(COp_KCAddCallback::Callback9), 630 NewKCCallbackUPP(COp_KCAddCallback::Callback10) }; 631 632// ��������������������������������������������������������������������������� 633// � COp_KCAddCallback 634// ��������������������������������������������������������������������������� 635COp_KCAddCallback::COp_KCAddCallback() 636 :mEvent("KCEvent") 637{ 638 AddParam(mEvent); 639} 640 641// ��������������������������������������������������������������������������� 642// � Operate 643// ��������������������������������������������������������������������������� 644OSStatus 645COp_KCAddCallback::Operate() 646{ 647 mStatus = ::KCAddCallback( 648 COp_KCAddCallback::sCallbacks[mEvent], 649 (KCEventMask)(1 << (KCEvent)mEvent), 650 (void *)this); 651 return(mStatus); 652} 653 654// ��������������������������������������������������������������������������� 655// � Operate 656// ��������������������������������������������������������������������������� 657#define KCADDCALLBACK(N) \ 658OSStatus \ 659COp_KCAddCallback::Callback ## N( \ 660 KCEvent inKeychainEvent, \ 661 KCCallbackInfo *inInfo, \ 662 void *inContext) \ 663{ \ 664 COp_KCAddCallback::sCounter[inKeychainEvent]++; \ 665 return noErr; \ 666} 667 668KCADDCALLBACK(0) 669KCADDCALLBACK(1) 670KCADDCALLBACK(2) 671KCADDCALLBACK(3) 672KCADDCALLBACK(4) 673KCADDCALLBACK(5) 674KCADDCALLBACK(6) 675KCADDCALLBACK(7) 676KCADDCALLBACK(8) 677KCADDCALLBACK(9) 678KCADDCALLBACK(10) 679 680#undef KCADDCALLBACK 681 682#pragma mark - 683// ��������������������������������������������������������������������������� 684// � COp_KCRemoveCallback 685// ��������������������������������������������������������������������������� 686COp_KCRemoveCallback::COp_KCRemoveCallback() 687 :mEvent("KCEvent"), 688 mIdleCount("IdleCount"), 689 mLockCount("LockCount"), 690 mUnlockCount("UnlockCount"), 691 mAddCount("AddCount"), 692 mDeleteCount("DeleteCount"), 693 mUpdateCount("UpdateCount"), 694 mChangeIdentityCount("ChangeIdentityCount"), 695 mFindCount("FindCount"), 696 mSystemCount("SystemCount"), 697 mDefaultChangedCount("DefaultChangedCount"), 698 mDataAccessCount("DataAccessCount") 699{ 700 AddParam(mEvent); 701 702 AddResult(mIdleCount); 703 AddResult(mLockCount); 704 AddResult(mUnlockCount); 705 AddResult(mAddCount); 706 AddResult(mDeleteCount); 707 AddResult(mUpdateCount); 708 AddResult(mChangeIdentityCount); 709 AddResult(mFindCount); 710 AddResult(mSystemCount); 711 AddResult(mDefaultChangedCount); 712 AddResult(mDataAccessCount); 713} 714 715// ��������������������������������������������������������������������������� 716// � Operate 717// ��������������������������������������������������������������������������� 718OSStatus 719COp_KCRemoveCallback::Operate() 720{ 721 // Receive a few events so we make sure we get all pending notifications (callbacks) 722 EventRecord er; 723 for (int ix = 0; ix < 142; ix++) 724 GetNextEvent(0, &er); 725 726 mStatus = ::KCRemoveCallback( 727 COp_KCAddCallback::sCallbacks[mEvent]); 728 729 // Copy the current results 730 UInt16 i = 0; 731 tParamList::iterator aIterator = mResultList.begin(); 732 CParamUInt32 * aParam = static_cast<CParamUInt32 *>(*aIterator); 733 while(aIterator != mResultList.end()){ 734 if(aParam){ 735 *aParam = COp_KCAddCallback::sCounter[i]; 736 i++; 737 } 738 aParam = static_cast<CParamUInt32 *>(*(++aIterator)); 739 } 740 741 // reset the counter 742 COp_KCAddCallback::sCounter[mEvent] = 0; 743 744 return(mStatus); 745} 746 747#pragma mark - 748// ��������������������������������������������������������������������������� 749// � COp_KCSetInteractionAllowed 750// ��������������������������������������������������������������������������� 751COp_KCSetInteractionAllowed::COp_KCSetInteractionAllowed() 752 :mAllow("AllowInteraction") 753{ 754 AddParam(mAllow); 755} 756// ��������������������������������������������������������������������������� 757// � Operate 758// ��������������������������������������������������������������������������� 759OSStatus 760COp_KCSetInteractionAllowed::Operate() 761{ 762 mStatus = ::KCSetInteractionAllowed(mAllow); 763 return(mStatus); 764} 765 766#pragma mark - 767// ��������������������������������������������������������������������������� 768// � COp_KCIsInteractionAllowed 769// ��������������������������������������������������������������������������� 770COp_KCIsInteractionAllowed::COp_KCIsInteractionAllowed() 771 :mAllow("AllowInteraction") 772{ 773 AddResult(mAllow); 774} 775// ��������������������������������������������������������������������������� 776// � Operate 777// ��������������������������������������������������������������������������� 778OSStatus 779COp_KCIsInteractionAllowed::Operate() 780{ 781 mStatus = noErr; 782 mAllow = ::KCIsInteractionAllowed(); 783 return(mStatus); 784} 785