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