KeychainCore.h

Go to the documentation of this file.

 
#ifndef __KEYCHAINCORE__
#define __KEYCHAINCORE__
 
#ifndef __MACTYPES__
#include <MacTypes.h>
#endif
 
#ifndef __FILES__
#include <Files.h>
#endif
 
#ifndef __ALIASES__
#include <Aliases.h>
#endif
 
#ifndef __CODEFRAGMENTS__
#include <CodeFragments.h>
#endif
 
#ifndef __MACERRORS__
#include <MacErrors.h>
#endif
 
#ifndef __PROCESSES__
#include <Processes.h>
#endif
 
#ifndef __EVENTS__
#include <Events.h>
#endif
 
#if PRAGMA_ONCE
#pragma once
#endif
 
#ifdef __cplusplus
extern "C"
{
#endif
 
#if PRAGMA_IMPORT
#pragma import on
#endif
 
#if PRAGMA_STRUCT_ALIGN
#pragma options align = mac68k
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(push, 2)
#elif PRAGMA_STRUCT_PACK
#pragma pack(2)
#endif
 
#ifndef __SEC_TYPES__
#define __SEC_TYPES__
  typedef struct OpaqueSecKeychainRef *SecKeychainRef;
  typedef struct OpaqueSecKeychainItemRef *SecKeychainItemRef;
  typedef struct OpaqueSecKeychainSearchRef *SecKeychainSearchRef;
  typedef OSType SecKeychainAttrType;
  typedef UInt32 SecKeychainStatus;
  struct SecKeychainAttribute
  {
    SecKeychainAttrType tag; 
    UInt32 length;           
    void *data;              
  };
  typedef struct SecKeychainAttribute SecKeychainAttribute;
  typedef SecKeychainAttribute *SecKeychainAttributePtr;
  struct SecKeychainAttributeList
  {
    UInt32 count;               
    SecKeychainAttribute *attr; 
  };
  typedef struct SecKeychainAttributeList SecKeychainAttributeList;
#endif
 
  typedef SecKeychainRef KCRef;
  typedef SecKeychainItemRef KCItemRef;
  typedef SecKeychainSearchRef KCSearchRef;
  typedef SecKeychainAttribute KCAttribute;
  typedef SecKeychainAttributeList KCAttributeList;
  typedef SecKeychainAttrType KCAttrType;
  typedef SecKeychainStatus KCStatus;
  typedef UInt16 KCEvent;
  enum
  {
    kIdleKCEvent = 0,                
    kLockKCEvent = 1,                
    kUnlockKCEvent = 2,              
    kAddKCEvent = 3,                 
    kDeleteKCEvent = 4,              
    kUpdateKCEvent = 5,              
    kPasswordChangedKCEvent = 6,     
    kSystemKCEvent = 8,              
    kDefaultChangedKCEvent = 9,      
    kDataAccessKCEvent = 10,         
    kKeychainListChangedKCEvent = 11 
  };
 
  typedef UInt16 KCEventMask;
  enum
  {
    kIdleKCEventMask = 1 << kIdleKCEvent,
    kLockKCEventMask = 1 << kLockKCEvent,
    kUnlockKCEventMask = 1 << kUnlockKCEvent,
    kAddKCEventMask = 1 << kAddKCEvent,
    kDeleteKCEventMask = 1 << kDeleteKCEvent,
    kUpdateKCEventMask = 1 << kUpdateKCEvent,
    kPasswordChangedKCEventMask = 1 << kPasswordChangedKCEvent,
    kSystemEventKCEventMask = 1 << kSystemKCEvent,
    kDefaultChangedKCEventMask = 1 << kDefaultChangedKCEvent,
    kDataAccessKCEventMask = 1 << kDataAccessKCEvent,
    kEveryKCEventMask = 0xFFFF 
  };
 
  typedef UInt8 AFPServerSignature[16];
  typedef UInt8 KCPublicKeyHash[20];
  struct KCCallbackInfo
  {
    UInt32 version;
    KCItemRef item;
    ProcessSerialNumber processID;
    EventRecord event;
    KCRef keychain;
  };
  typedef struct KCCallbackInfo KCCallbackInfo;
  enum
  {
    kUnlockStateKCStatus = 1,
    kRdPermKCStatus = 2,
    kWrPermKCStatus = 4
  };
 
  enum
  {
    kCertificateKCItemClass = FOUR_CHAR_CODE('cert'), 
    kAppleSharePasswordKCItemClass =
        FOUR_CHAR_CODE('ashp'), 
    kInternetPasswordKCItemClass =
        FOUR_CHAR_CODE('inet'),                          
    kGenericPasswordKCItemClass = FOUR_CHAR_CODE('genp') 
  };
 
  typedef FourCharCode KCItemClass;
  enum
  {
    kClassKCItemAttr = FOUR_CHAR_CODE('clas'), 
    kCreationDateKCItemAttr =
        FOUR_CHAR_CODE('cdat'), 
    kModDateKCItemAttr =
        FOUR_CHAR_CODE('mdat'), 
    kDescriptionKCItemAttr =
        FOUR_CHAR_CODE('desc'), 
    kCommentKCItemAttr =
        FOUR_CHAR_CODE('icmt'),                  
    kCreatorKCItemAttr = FOUR_CHAR_CODE('crtr'), 
    kTypeKCItemAttr = FOUR_CHAR_CODE('type'),    
    kScriptCodeKCItemAttr =
        FOUR_CHAR_CODE('scrp'),                     
    kLabelKCItemAttr = FOUR_CHAR_CODE('labl'),      
    kInvisibleKCItemAttr = FOUR_CHAR_CODE('invi'),  
    kNegativeKCItemAttr = FOUR_CHAR_CODE('nega'),   
    kCustomIconKCItemAttr = FOUR_CHAR_CODE('cusi'), 
    kAccountKCItemAttr = FOUR_CHAR_CODE('acct'),    
    kServiceKCItemAttr = FOUR_CHAR_CODE('svce'), 
    kGenericKCItemAttr =
        FOUR_CHAR_CODE('gena'), 
    kSecurityDomainKCItemAttr =
        FOUR_CHAR_CODE('sdmn'), 
    kServerKCItemAttr =
        FOUR_CHAR_CODE('srvr'), 
    kAuthTypeKCItemAttr =
        FOUR_CHAR_CODE('atyp'),               
    kPortKCItemAttr = FOUR_CHAR_CODE('port'), 
    kPathKCItemAttr = FOUR_CHAR_CODE('path'), 
    kVolumeKCItemAttr = FOUR_CHAR_CODE('vlme'), 
    kAddressKCItemAttr = FOUR_CHAR_CODE(
        'addr'), 
    kSignatureKCItemAttr =
        FOUR_CHAR_CODE('ssig'),                   
    kProtocolKCItemAttr = FOUR_CHAR_CODE('ptcl'), 
    kSubjectKCItemAttr = FOUR_CHAR_CODE(
        'subj'), 
    kCommonNameKCItemAttr =
        FOUR_CHAR_CODE('cn  '), 
    kIssuerKCItemAttr = FOUR_CHAR_CODE(
        'issu'), 
    kSerialNumberKCItemAttr = FOUR_CHAR_CODE(
        'snbr'), 
    kEMailKCItemAttr =
        FOUR_CHAR_CODE('mail'), 
    kPublicKeyHashKCItemAttr = FOUR_CHAR_CODE(
        'hpky'), 
    kIssuerURLKCItemAttr = FOUR_CHAR_CODE(
        'iurl'),                                   
    kEncryptKCItemAttr = FOUR_CHAR_CODE('encr'),   
    kDecryptKCItemAttr = FOUR_CHAR_CODE('decr'),   
    kSignKCItemAttr = FOUR_CHAR_CODE('sign'),      
    kVerifyKCItemAttr = FOUR_CHAR_CODE('veri'),    
    kWrapKCItemAttr = FOUR_CHAR_CODE('wrap'),      
    kUnwrapKCItemAttr = FOUR_CHAR_CODE('unwr'),    
    kStartDateKCItemAttr = FOUR_CHAR_CODE('sdat'), 
    kEndDateKCItemAttr = FOUR_CHAR_CODE('edat')    
  };
 
  typedef FourCharCode KCItemAttr;
  enum
  {
    kKCAuthTypeNTLM = FOUR_CHAR_CODE('ntlm'),
    kKCAuthTypeMSN = FOUR_CHAR_CODE('msna'),
    kKCAuthTypeDPA = FOUR_CHAR_CODE('dpaa'),
    kKCAuthTypeRPA = FOUR_CHAR_CODE('rpaa'),
    kKCAuthTypeHTTPDigest = FOUR_CHAR_CODE('httd'),
    kKCAuthTypeDefault = FOUR_CHAR_CODE('dflt')
  };
 
  typedef FourCharCode KCAuthType;
  enum
  {
    kKCProtocolTypeFTP = FOUR_CHAR_CODE('ftp '),
    kKCProtocolTypeFTPAccount = FOUR_CHAR_CODE('ftpa'),
    kKCProtocolTypeHTTP = FOUR_CHAR_CODE('http'),
    kKCProtocolTypeIRC = FOUR_CHAR_CODE('irc '),
    kKCProtocolTypeNNTP = FOUR_CHAR_CODE('nntp'),
    kKCProtocolTypePOP3 = FOUR_CHAR_CODE('pop3'),
    kKCProtocolTypeSMTP = FOUR_CHAR_CODE('smtp'),
    kKCProtocolTypeSOCKS = FOUR_CHAR_CODE('sox '),
    kKCProtocolTypeIMAP = FOUR_CHAR_CODE('imap'),
    kKCProtocolTypeLDAP = FOUR_CHAR_CODE('ldap'),
    kKCProtocolTypeAppleTalk = FOUR_CHAR_CODE('atlk'),
    kKCProtocolTypeAFP = FOUR_CHAR_CODE('afp '),
    kKCProtocolTypeTelnet = FOUR_CHAR_CODE('teln')
  };
 
  typedef FourCharCode KCProtocolType;
  typedef UInt32 KCCertAddOptions;
  enum
  {
    kSecOptionReserved =
        0x000000FF,      
    kCertUsageShift = 8, 
    kCertUsageSigningAdd = 1 << (kCertUsageShift + 0),
    kCertUsageSigningAskAndAdd = 1 << (kCertUsageShift + 1),
    kCertUsageVerifyAdd = 1 << (kCertUsageShift + 2),
    kCertUsageVerifyAskAndAdd = 1 << (kCertUsageShift + 3),
    kCertUsageEncryptAdd = 1 << (kCertUsageShift + 4),
    kCertUsageEncryptAskAndAdd = 1 << (kCertUsageShift + 5),
    kCertUsageDecryptAdd = 1 << (kCertUsageShift + 6),
    kCertUsageDecryptAskAndAdd = 1 << (kCertUsageShift + 7),
    kCertUsageKeyExchAdd = 1 << (kCertUsageShift + 8),
    kCertUsageKeyExchAskAndAdd = 1 << (kCertUsageShift + 9),
    kCertUsageRootAdd = 1 << (kCertUsageShift + 10),
    kCertUsageRootAskAndAdd = 1 << (kCertUsageShift + 11),
    kCertUsageSSLAdd = 1 << (kCertUsageShift + 12),
    kCertUsageSSLAskAndAdd = 1 << (kCertUsageShift + 13),
    kCertUsageAllAdd = 0x7FFFFF00
  };
 
  typedef UInt16 KCVerifyStopOn;
  enum
  {
    kPolicyKCStopOn = 0,
    kNoneKCStopOn = 1,
    kFirstPassKCStopOn = 2,
    kFirstFailKCStopOn = 3
  };
 
  typedef UInt32 KCCertSearchOptions;
  enum
  {
    kCertSearchShift = 0, 
    kCertSearchSigningIgnored = 0,
    kCertSearchSigningAllowed = 1 << (kCertSearchShift + 0),
    kCertSearchSigningDisallowed = 1 << (kCertSearchShift + 1),
    kCertSearchSigningMask =
        ((kCertSearchSigningAllowed) | (kCertSearchSigningDisallowed)),
    kCertSearchVerifyIgnored = 0,
    kCertSearchVerifyAllowed = 1 << (kCertSearchShift + 2),
    kCertSearchVerifyDisallowed = 1 << (kCertSearchShift + 3),
    kCertSearchVerifyMask =
        ((kCertSearchVerifyAllowed) | (kCertSearchVerifyDisallowed)),
    kCertSearchEncryptIgnored = 0,
    kCertSearchEncryptAllowed = 1 << (kCertSearchShift + 4),
    kCertSearchEncryptDisallowed = 1 << (kCertSearchShift + 5),
    kCertSearchEncryptMask =
        ((kCertSearchEncryptAllowed) | (kCertSearchEncryptDisallowed)),
    kCertSearchDecryptIgnored = 0,
    kCertSearchDecryptAllowed = 1 << (kCertSearchShift + 6),
    kCertSearchDecryptDisallowed = 1 << (kCertSearchShift + 7),
    kCertSearchDecryptMask =
        ((kCertSearchDecryptAllowed) | (kCertSearchDecryptDisallowed)),
    kCertSearchWrapIgnored = 0,
    kCertSearchWrapAllowed = 1 << (kCertSearchShift + 8),
    kCertSearchWrapDisallowed = 1 << (kCertSearchShift + 9),
    kCertSearchWrapMask =
        ((kCertSearchWrapAllowed) | (kCertSearchWrapDisallowed)),
    kCertSearchUnwrapIgnored = 0,
    kCertSearchUnwrapAllowed = 1 << (kCertSearchShift + 10),
    kCertSearchUnwrapDisallowed = 1 << (kCertSearchShift + 11),
    kCertSearchUnwrapMask =
        ((kCertSearchUnwrapAllowed) | (kCertSearchUnwrapDisallowed)),
    kCertSearchPrivKeyRequired = 1 << (kCertSearchShift + 12),
    kCertSearchAny = 0
  };
 
  enum
  {
    kAnyPort = 0
  };
 
  enum
  {
    kAnyProtocol = 0,
    kAnyAuthType = 0
  };
 
  OSStatus
  KCGetKeychainManagerVersion(UInt32 *returnVers);
 
#if TARGET_RT_MAC_CFM
#ifdef __cplusplus
  inline pascal Boolean KeychainManagerAvailable()
  {
    return (
        (KCGetKeychainManagerVersion != (void *)kUnresolvedCFragSymbolAddress) &&
        (KCGetKeychainManagerVersion(nil) != cfragNoSymbolErr));
  }
#else
#define KeychainManagerAvailable()                                           \
  ((KCGetKeychainManagerVersion != (void *)kUnresolvedCFragSymbolAddress) && \
   (KCGetKeychainManagerVersion(nil) != cfragNoSymbolErr))
#endif
#elif TARGET_RT_MAC_MACHO
#ifdef __cplusplus
inline pascal Boolean KeychainManagerAvailable() { return true; }
#else
#define KeychainManagerAvailable() (true)
#endif
#endif 
  OSStatus
  KCSetInteractionAllowed(Boolean state);
 
  Boolean
  KCIsInteractionAllowed(void);
 
  OSStatus
  KCMakeKCRefFromFSSpec(FSSpec *keychainFSSpec, KCRef *keychain);
 
  OSStatus
  KCMakeKCRefFromAlias(AliasHandle keychainAlias, KCRef *keychain);
 
  OSStatus
  KCMakeAliasFromKCRef(KCRef keychain, AliasHandle *keychainAlias);
 
  OSStatus
  KCReleaseKeychain(KCRef *keychain);
 
  OSStatus
  KCGetDefaultKeychain(KCRef *keychain);
 
  OSStatus
  KCSetDefaultKeychain(KCRef keychain);
 
  OSStatus
  KCGetStatus(KCRef keychain, 
              UInt32 *keychainStatus);
 
  OSStatus
  KCGetKeychain(KCItemRef item, KCRef *keychain);
 
  OSStatus
  KCGetKeychainName(KCRef keychain, StringPtr keychainName);
 
  UInt16
  KCCountKeychains(void);
 
  OSStatus
  KCGetIndKeychain(UInt16 index, KCRef *keychain);
 
  typedef CALLBACK_API(OSStatus, KCCallbackProcPtr)(KCEvent keychainEvent,
                                                    KCCallbackInfo *info,
                                                    void *userContext);
  typedef STACK_UPP_TYPE(KCCallbackProcPtr) KCCallbackUPP;
  KCCallbackUPP
  NewKCCallbackUPP(KCCallbackProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppKCCallbackProcInfo = 0x00000FB0
  }; 
#ifdef __cplusplus
  inline KCCallbackUPP NewKCCallbackUPP(KCCallbackProcPtr userRoutine)
  {
    return (KCCallbackUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppKCCallbackProcInfo, GetCurrentArchitecture());
  }
#else
#define NewKCCallbackUPP(userRoutine)   \
  (KCCallbackUPP) NewRoutineDescriptor( \
      (ProcPtr)(userRoutine), uppKCCallbackProcInfo, GetCurrentArchitecture())
#endif
#endif
 
  void
  DisposeKCCallbackUPP(KCCallbackUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeKCCallbackUPP(KCCallbackUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeKCCallbackUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  OSStatus
  InvokeKCCallbackUPP(KCEvent keychainEvent, KCCallbackInfo *info,
                      void *userContext, KCCallbackUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline OSStatus InvokeKCCallbackUPP(KCEvent keychainEvent, KCCallbackInfo *info,
                                      void *userContext, KCCallbackUPP userUPP)
  {
    return (OSStatus)CALL_THREE_PARAMETER_UPP(userUPP, uppKCCallbackProcInfo,
                                              keychainEvent, info, userContext);
  }
#else
#define InvokeKCCallbackUPP(keychainEvent, info, userContext, userUPP)  \
  (OSStatus) CALL_THREE_PARAMETER_UPP((userUPP), uppKCCallbackProcInfo, \
                                      (keychainEvent), (info), (userContext))
#endif
#endif
 
#if CALL_NOT_IN_CARBON || OLDROUTINENAMES
#define NewKCCallbackProc(userRoutine) NewKCCallbackUPP(userRoutine)
#define CallKCCallbackProc(userRoutine, keychainEvent, info, userContext) \
  InvokeKCCallbackUPP(keychainEvent, info, userContext, userRoutine)
#endif 
  OSStatus
  KCAddCallback(KCCallbackUPP callbackProc, KCEventMask eventMask,
                void *userContext);
 
  OSStatus
  KCRemoveCallback(KCCallbackUPP callbackProc);
 
  OSStatus
  KCNewItem(KCItemClass itemClass, OSType itemCreator, UInt32 length,
            const void *data, KCItemRef *item);
 
  OSStatus
  KCSetAttribute(KCItemRef item, KCAttribute *attr);
 
  OSStatus
  KCGetAttribute(KCItemRef item, KCAttribute *attr, UInt32 *actualLength);
 
  OSStatus
  KCSetData(KCItemRef item, UInt32 length, const void *data);
 
  OSStatus
  KCUpdateItem(KCItemRef item);
 
  OSStatus
  KCReleaseItem(KCItemRef *item);
 
  OSStatus
  KCCopyItem(KCItemRef item, KCRef destKeychain, KCItemRef *copy);
 
  OSStatus
  KCFindFirstItem(KCRef keychain,                  
                  const KCAttributeList *attrList, 
                  KCSearchRef *search, KCItemRef *item);
 
  OSStatus
  KCFindNextItem(KCSearchRef search, KCItemRef *item);
 
  OSStatus
  KCReleaseSearch(KCSearchRef *search);
 
  OSStatus
  kcgetkeychainname(KCRef keychain, char *keychainName);
 
  OSStatus
  KCDeleteItem(KCItemRef item);
 
  OSStatus
  KCGetData(KCItemRef item, UInt32 maxLength, void *data, UInt32 *actualLength);
 
  OSStatus
  KCAddAppleSharePassword(AFPServerSignature *serverSignature,
                          StringPtr serverAddress, StringPtr serverName,
                          StringPtr volumeName, StringPtr accountName,
                          UInt32 passwordLength, const void *passwordData,
                          KCItemRef *item); 
  OSStatus
  KCFindAppleSharePassword(AFPServerSignature *serverSignature, 
                           StringPtr serverAddress,             
                           StringPtr serverName,                
                           StringPtr volumeName,                
                           StringPtr accountName,               
                           UInt32 maxLength, void *passwordData,
                           UInt32 *actualLength,
                           KCItemRef *item); 
  OSStatus
  KCAddInternetPassword(StringPtr serverName, StringPtr securityDomain,
                        StringPtr accountName, UInt16 port, OSType protocol,
                        OSType authType, UInt32 passwordLength,
                        const void *passwordData,
                        KCItemRef *item); 
  OSStatus
  KCAddInternetPasswordWithPath(StringPtr serverName, StringPtr securityDomain,
                                StringPtr accountName, StringPtr path,
                                UInt16 port, OSType protocol, OSType authType,
                                UInt32 passwordLength, const void *passwordData,
                                KCItemRef *item); 
  OSStatus
  KCFindInternetPassword(StringPtr serverName,     
                         StringPtr securityDomain, 
                         StringPtr accountName,    
                         UInt16 port, OSType protocol, OSType authType,
                         UInt32 maxLength, void *passwordData,
                         UInt32 *actualLength,
                         KCItemRef *item); 
  OSStatus
  KCFindInternetPasswordWithPath(StringPtr serverName,     
                                 StringPtr securityDomain, 
                                 StringPtr accountName,    
                                 StringPtr path,           
                                 UInt16 port, OSType protocol, OSType authType,
                                 UInt32 maxLength, void *passwordData,
                                 UInt32 *actualLength,
                                 KCItemRef *item); 
  OSStatus
  KCAddGenericPassword(StringPtr serviceName, StringPtr accountName,
                       UInt32 passwordLength, const void *passwordData,
                       KCItemRef *item); 
  OSStatus
  KCFindGenericPassword(StringPtr serviceName, 
                        StringPtr accountName, 
                        UInt32 maxLength, void *passwordData,
                        UInt32 *actualLength, KCItemRef *item); 
  OSStatus
  KCLock(KCRef keychain);
 
  OSStatus
  kcaddapplesharepassword(AFPServerSignature *serverSignature,
                          const char *serverAddress, const char *serverName,
                          const char *volumeName, const char *accountName,
                          UInt32 passwordLength, const void *passwordData,
                          KCItemRef *item); 
  OSStatus
  kcfindapplesharepassword(AFPServerSignature *serverSignature, 
                           const char *serverAddress,           
                           const char *serverName,              
                           const char *volumeName,              
                           const char *accountName,             
                           UInt32 maxLength, void *passwordData,
                           UInt32 *actualLength,
                           KCItemRef *item); 
  OSStatus
  kcaddinternetpassword(const char *serverName, const char *securityDomain,
                        const char *accountName, UInt16 port, OSType protocol,
                        OSType authType, UInt32 passwordLength,
                        const void *passwordData,
                        KCItemRef *item); 
  OSStatus
  kcaddinternetpasswordwithpath(const char *serverName,
                                const char *securityDomain,
                                const char *accountName, const char *path,
                                UInt16 port, OSType protocol, OSType authType,
                                UInt32 passwordLength, const void *passwordData,
                                KCItemRef *item); 
  OSStatus
  kcfindinternetpassword(const char *serverName,     
                         const char *securityDomain, 
                         const char *accountName,    
                         UInt16 port, OSType protocol, OSType authType,
                         UInt32 maxLength, void *passwordData,
                         UInt32 *actualLength,
                         KCItemRef *item); 
  OSStatus
  kcfindinternetpasswordwithpath(const char *serverName,     
                                 const char *securityDomain, 
                                 const char *accountName,    
                                 const char *path,           
                                 UInt16 port, OSType protocol, OSType authType,
                                 UInt32 maxLength, void *passwordData,
                                 UInt32 *actualLength,
                                 KCItemRef *item); 
  OSStatus
  kcaddgenericpassword(const char *serviceName, const char *accountName,
                       UInt32 passwordLength, const void *passwordData,
                       KCItemRef *item); 
  OSStatus
  kcfindgenericpassword(const char *serviceName, 
                        const char *accountName, 
                        UInt32 maxLength, void *passwordData,
                        UInt32 *actualLength, KCItemRef *item); 
#if PRAGMA_STRUCT_ALIGN
#pragma options align = reset
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(pop)
#elif PRAGMA_STRUCT_PACK
#pragma pack()
#endif
 
#ifdef PRAGMA_IMPORT_OFF
#pragma import off
#elif PRAGMA_IMPORT
#pragma import reset
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif