SecurityTests/testKeychainAPI/testKeychainAPI/KCOperation.h

   1 // ======================================================================
   2 //      File:           KCOperation.h
   3 //
   4 //      pure virtual base class for performing operations in KeychainLib
   5 //  (based on Dave Akhond's Operation for CDSA
   6 //
   7 //      Copyright:      Copyright (c) 2000,2003,2008 Apple Inc. All Rights Reserved.
   8 //
   9 //      Change History (most recent first):
  10 //
  11 //               <1>    2/22/00 em              Created.
  12 // ======================================================================
  13
  14 #ifndef __KC_OPERATION__
  15 #define __KC_OPERATION__
  16
  17 #ifdef _CPP_UTILITIES
  18 #pragma export on
  19 #endif
  20
  21 #include <stdio.h>
  22 #include <Carbon/Carbon.h>
  23 #include <vector.h>
  24 #undef check
  25 #if TARGET_RT_MAC_MACHO
  26         #include <OSServices/KeychainCore.h>
  27         #include <OSServices/KeychainCorePriv.h>
  28         #include <SecurityHI/KeychainHI.h>
  29 #else
  30         #include <Keychain.h>
  31 #endif
  32
  33 #include "testKeychainAPI.h"
  34 #include "KCParamUtility.h"
  35 #include "KCOperationID.h"
  36
  37
  38 // ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  39 //      ¥ Operation
  40 // ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  41 class Operation {
  42 public:
  43                                                                                         // Birth & Death
  44                                                                 Operation():mStatus(noErr){}
  45         virtual                                         ~Operation(){}
  46
  47         virtual void                            SetClient(void *inClient);
  48         virtual OSStatus                        Operate() = 0;
  49         virtual eKCOperationID          GetID() = 0;
  50
  51         virtual void                            ReadArguments(
  52                                     FILE                        *inFile);
  53
  54         virtual void                            WriteArguments(
  55                                     FILE                        *inFile);
  56
  57         virtual void                            WriteResults(
  58                                     FILE                        *inFile);
  59
  60         static int                                      ReadScript(
  61                                     FILE                        *inFile,
  62                                     eKCOperationID      &outID);
  63
  64         virtual void                            ReadScript(
  65                                     FILE                        *inFile);
  66
  67         virtual void                            WriteScript(
  68                                     FILE                        *inFile);
  69
  70         virtual void                            GenerateScript(
  71                                     FILE                        *inFile);
  72
  73         virtual bool                            RunScript(
  74                                     FILE                        *inFile);
  75
  76         virtual bool                            CompareResults(
  77                                                                         FILE                    *inFile);
  78 protected:
  79         CTestApp                                        *mClient;
  80         OSStatus                                        mStatus;
  81         tParamList                                      mParamList;
  82         tParamList                                      mResultList;
  83
  84         virtual void                            AddParam(CParam &inParam){ mParamList.push_back(&inParam);}
  85         virtual void                            AddResult(CParam &inParam){ mResultList.push_back(&inParam);}
  86
  87
  88 };
  89
  90 // ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  91 //      ¥ KCOperation
  92 // ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
  93 class KCOperation : public Operation {
  94 public:
  95                                                                 KCOperation():mKeychainIndex("KeychainIndex"), mAliasIndex("AliasIndex") {}
  96         virtual                                         ~KCOperation(){}
  97
  98         virtual void                            AddAlias(AliasHandle alias)
  99                                 {
 100                                     sAliasList.push_back(alias);
 101                                                                         mAliasIndex = (UInt32)(sAliasList.size()-1);
 102                                 }
 103
 104         virtual void                            AddKeychain(KCRef &inKeychain)
 105                                 {
 106                                     sKCRefList.push_back(inKeychain);
 107                                     mKeychainIndex = (UInt32)(sKCRefList.size()-1);
 108                                 }
 109
 110         virtual AliasHandle                     GetAlias()
 111                                 {
 112                                                                         if((UInt32)mAliasIndex < sAliasList.size())
 113                                                                                 return sAliasList[(UInt32)mAliasIndex];
 114                                                                         else
 115                                                                                 return NULL;
 116                                 }
 117
 118         virtual KCRef                           GetKeychain()
 119                                 {
 120                                                                         if((UInt32)mKeychainIndex < sKCRefList.size())
 121                                                                                 return sKCRefList[(UInt32)mKeychainIndex];
 122                                                                         else
 123                                                                                 return NULL;
 124                                 }
 125
 126         static  void                            Cleanup()
 127                                                                 {
 128                                                                                 // ¥¥¥ need to release each keychain first
 129                                                                         sAliasList.clear();
 130                                                                         sKCRefList.clear();
 131                                                                 }
 132 protected:
 133         class CKeychainIndex : public CUInt32
 134         {
 135         public:
 136                 CKeychainIndex &                operator = (const UInt32 &inData){ data = inData; return *this; }
 137                 bool                                    operator == (const UInt32 inData) const
 138                                                                 {
 139                                                                         return (CKCRef(KCOperation::sKCRefList[data]) == KCOperation::sKCRefList[inData]);
 140                                                                 }
 141         };
 142         typedef TParam<CKeychainIndex, POD_STRUCT(UInt32), UInt32> CParamKeychainIndex;
 143
 144         class CAliasIndex : public CUInt32
 145         {
 146         public:
 147                 CAliasIndex &           operator = (const UInt32 &inData){ data = inData; return *this; }
 148                 bool                                    operator == (const UInt32 inData) const
 149                                                                 {
 150                                                                         return (CAliasHandle(KCOperation::sAliasList[data]) == KCOperation::sAliasList[inData]);
 151                                                                 }
 152         };
 153         typedef TParam<CAliasIndex, POD_STRUCT(UInt32), UInt32> CParamAliasIndex;
 154
 155         CParamKeychainIndex                     mKeychainIndex;
 156         CParamAliasIndex                        mAliasIndex;
 157         static vector<KCRef>            sKCRefList;
 158         static vector<AliasHandle>      sAliasList;
 159
 160         friend class CKeychainIndex;
 161         friend class CAliasIndex;
 162 };
 163
 164
 165 // ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
 166 //      ¥ KCItemOperation
 167 // ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
 168 class KCItemOperation : public KCOperation {
 169 public:
 170                                 KCItemOperation():mItemIndex("ItemIndex"){}
 171         virtual                                         ~KCItemOperation(){}
 172
 173         virtual void                            AddItem(KCItemRef &inItem)
 174                                 {
 175                                     sKCItemRefList.push_back(inItem);
 176                                                                         mItemIndex = (UInt32)(sKCItemRefList.size()-1);
 177                                 }
 178
 179         virtual KCItemRef                       GetItem()
 180                                 {
 181                                                                         if((UInt32)mItemIndex < sKCItemRefList.size())
 182                                                                                 return sKCItemRefList[(UInt32)mItemIndex];
 183                                                                         else
 184                                                                                 return NULL;
 185                                 }
 186
 187         static  void                            Cleanup()
 188                                                                 {
 189                                                                                 // ¥¥¥ need to release each item first
 190                                                                         sKCItemRefList.clear();
 191                                                                 }
 192 protected:
 193         class CItemIndex : public CUInt32
 194         {
 195         public:
 196                 CItemIndex &                    operator = (const UInt32 &inData){ data = inData; return *this; }
 197                 bool                                    operator == (const UInt32 inData) const
 198                                                                 {
 199                                                                         return(CKCItemRef(KCItemOperation::sKCItemRefList[data]) == KCItemOperation::sKCItemRefList[inData]);
 200                                                                 }
 201         };
 202         typedef TParam<CItemIndex, POD_STRUCT(UInt32), UInt32> CParamItemIndex;
 203         CParamItemIndex                         mItemIndex;
 204
 205         static vector<KCItemRef>        sKCItemRefList;
 206
 207         friend class CItemIndex;
 208 };
 209
 210 // ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
 211 //      ¥ KCSearchOperation
 212 // ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
 213 class KCSearchOperation : public KCItemOperation {
 214 public:
 215                                 KCSearchOperation():mSearchIndex("SearchIndex"){}
 216         virtual                                         ~KCSearchOperation(){}
 217
 218         virtual void                            AddSearch(KCSearchRef &inSearch)
 219                                 {
 220                                     sKCSearchRefList.push_back(inSearch); mSearchIndex = (UInt32)(sKCSearchRefList.size()-1);
 221                                 }
 222
 223         virtual KCSearchRef                     GetSearch()
 224                                 {
 225                                                                         if((UInt32)mSearchIndex < sKCSearchRefList.size())
 226                                                                                 return sKCSearchRefList[(UInt32)mSearchIndex];
 227                                                                         else
 228                                                                                 return NULL;
 229                                 }
 230
 231         static  void                            Cleanup()
 232                                                                 {
 233                                                                                 // ¥¥¥ need to release each ref first
 234                                                                         sKCSearchRefList.clear();
 235                                                                 }
 236 protected:
 237         class CSearchIndex : public CUInt32
 238         {
 239         public:
 240                 CSearchIndex &                  operator = (const UInt32 &inData){ data = inData; return *this; }
 241                 bool                                    operator == (const UInt32 inData) const
 242                                                                 {
 243                                                                         return (data == inData) ||
 244                                                                                 (KCSearchOperation::sKCSearchRefList[data] == KCSearchOperation::sKCSearchRefList[inData]);
 245                                                                 }
 246         };
 247         typedef TParam<CSearchIndex, POD_STRUCT(UInt32), UInt32> CParamSearchIndex;
 248         CParamSearchIndex                       mSearchIndex;
 249
 250         static vector<KCSearchRef>      sKCSearchRefList;
 251
 252         friend class CSearchIndex;
 253 };
 254
 255 #ifdef _CPP_UTILITIES
 256 #pragma export off
 257 #endif
 258
 259 #endif // __KC_OPERATION__