--- /dev/null
+#ifndef __TRANSFORM__
+#define __TRANSFORM__
+
+#include <CoreFoundation/CFError.h>
+#include "CoreFoundationBasics.h"
+#include "SecTransform.h"
+#include "SecCustomTransform.h"
+#include <dispatch/dispatch.h>
+#include "misc.h"
+
+// Since we are doing everything in CF, we just define an
+// attribute as a CFDictionary containing a value and
+// a CFArray of objects which need notification when that
+// value changes
+
+// defines for transform externalization
+#define EXTERN_TRANSFORM_TRANSFORM_ARRAY CFSTR("TRANSFORMS")
+#define EXTERN_TRANSFORM_CONNECTION_ARRAY CFSTR("ARRAY")
+#define EXTERN_TRANSFORM_CUSTOM_EXPORTS_DICTIONARY CFSTR("CUSTOM_EXPORTS")
+
+#define EXTERN_TRANSFORM_NAME CFSTR("NAME")
+#define EXTERN_TRANSFORM_TYPE CFSTR("TYPE")
+#define EXTERN_TRANSFORM_STATE CFSTR("STATE")
+#define EXTERN_TRANSFORM_FROM_NAME CFSTR("FROM_NAME")
+#define EXTERN_TRANSFORM_FROM_ATTRIBUTE CFSTR("FROM_ATTRIBUTE")
+#define EXTERN_TRANSFORM_TO_NAME CFSTR("TO_NAME")
+#define EXTERN_TRANSFORM_TO_ATTRIBUTE CFSTR("TO_ATTRIBUTE")
+
+#ifndef __clang__
+#define GCC_BUG_WORKAROUND ::
+#else
+#define GCC_BUG_WORKAROUND
+#endif
+
+
+class Monitor;
+typedef CFTypeRef SecMonitorRef;
+
+struct transform_attribute {
+ CFStringRef name;
+ CFTypeRef value;
+ CFMutableArrayRef connections;
+ // NOTE: this does NOT have a reference.
+ class Transform *transform;
+ static CFTypeID cftype;
+
+ // NOTE: NULL is a valid value to pushback, so we can't just use pushback_value==NULL for "nothing pushed back"
+ // pb_empty => no value currently pushed back
+ // pb_value => we have a value, we havn't presented it yet (if pushback_value==NULL we won't present again until another attribute changes)
+ // pb_repush => pushed back value currently being re-processed
+ // pb_presented_once => we have a value, and tried to process it and got it back again (don't present until another attribute changes)
+ //
+ enum pushback_states { pb_empty, pb_value, pb_repush, pb_presented_once, pb_discard } pushback_state;
+ CFTypeRef pushback_value;
+
+ // (for pushback support; also need pushback state & value)
+ dispatch_queue_t q;
+ dispatch_semaphore_t semaphore;
+
+ // This attribute needs a value set, or to have something connected to it before running the transform
+ unsigned int required:1;
+ // This attribute needs to have an outgoing connection before running the transform
+ unsigned int requires_outbound_connection:1;
+ // This attribute should not be presented to the transform until after execution starts
+ unsigned int deferred:1;
+ // This attribute comes in N chunks followed by a NULL
+ unsigned int stream:1;
+ // This attribute should be saved when externalizing
+ unsigned int ignore_while_externalizing:1;
+ // Set by Transform::Connect
+ unsigned int has_incoming_connection:1;
+ // CustomTransform should't special case CFErrors for this attribute
+ unsigned int direct_error_handling:1;
+ // External sets are problematic, I think they should be disallowed full stop, but 7947393 says we need them sometimes
+ unsigned int allow_external_sets:1;
+ // Value has been created as a source (therefore deferred), give it special treatment
+ unsigned int has_been_deferred:1;
+
+ void *attribute_changed_block;
+ void *attribute_validate_block;
+};
+
+typedef void (^ActivityMonitor)(CFStringRef name, CFTypeRef value);
+
+class GroupTransform; // Forward reference so we do not have to include
+ // the header and break a circular dependency
+class BlockMonitor;
+
+class Transform : public CoreFoundationObject
+{
+ friend CFTypeRef SecTransformExecute(SecTransformRef tranformRef, CFErrorRef* errorRef);
+ friend CFTypeRef SecTransformGetAttribute(SecTransformRef transformRef, CFStringRef key);
+ friend class BlockMonitor;
+protected:
+ dispatch_queue_t mDispatchQueue, mActivationQueue;
+ dispatch_group_t mActivationPending;
+ CFMutableSetRef mAttributes;
+ CFMutableArrayRef mPushedback;
+ Boolean mIsActive;
+ Boolean mIsFinalizing;
+ Boolean mAlwaysSelfNotify, mProcessingPushbacks;
+ GroupTransform *mGroup;
+ CFErrorRef mAbortError;
+ CFStringRef mTypeName;
+
+ SecTransformAttributeRef AbortAH, DebugAH;
+
+ Transform(CFStringRef transformType, CFStringRef CFobjectType = CFSTR("SecTransform"));
+
+ transform_attribute *getTA(SecTransformStringOrAttributeRef attr, bool create_ok);
+ void TAGetAll(transform_attribute **attributes);
+ CFIndex GetAttributeCount();
+
+ CFDictionaryRef GetAHDictForSaveState(SecTransformStringOrAttributeRef key);
+
+ CFTypeRef ValueForNewAttribute(CFStringRef key, CFTypeRef value);
+ CFMutableDictionaryRef AddNewAttribute(CFStringRef key, CFTypeRef value);
+ CFErrorRef SetAttributeNoCallback(SecTransformStringOrAttributeRef key, CFTypeRef value);
+
+ CFErrorRef ProcessExecute(CFStringRef &outputAttached, SecMonitorRef monitor);
+ typedef void (^AccumulateDictonary)(CFDictionaryRef d);
+ CFErrorRef ProcessExternalize(CFMutableArrayRef transforms, CFMutableArrayRef connections);
+
+ void FinalizeForClang();
+
+ virtual void Finalize();
+ // subclasses with non-trivial finalization can implement this (default: delete this)
+ virtual void FinalizePhase2();
+ // subclasses that want to reject some connections can use this
+ virtual bool validConnectionPoint(CFStringRef attributeName);
+
+ void try_pushbacks();
+
+ void Initialize();
+
+ void ActivateInputs();
+
+ virtual std::string DebugDescription();
+
+ typedef CFErrorRef (^TransformOperation)(Transform*);
+ typedef void (^TransformAsyncOperation)(Transform*);
+ CFErrorRef ForAllNodes(bool parallel, bool includeOwningGroup, TransformOperation op);
+
+ CFErrorRef TraverseTransform(CFMutableSetRef visited, TransformOperation t);
+
+
+ CFErrorRef SendAttribute(SecTransformStringOrAttributeRef key, CFTypeRef value);
+ CFErrorRef SendMetaAttribute(SecTransformStringOrAttributeRef key, SecTransformMetaAttributeType type, CFTypeRef value);
+
+ // Abort all transforms in this transform's RootGroup, including this transform
+ virtual void AbortAllTransforms(CFTypeRef error);
+ // Abort just this transform (and maybe schedule a later call to AbortAllTransforms), should only be
+ // called via AbortAllTransforms
+ virtual void AbortJustThisTransform(CFErrorRef abortMsg);
+
+ void phase3Activation();
+ void DoPhase3Activation();
+
+ bool HasNoInboundConnections();
+ bool HasNoOutboundConnections();
+
+private:
+ CFErrorRef ExecuteOperation(CFStringRef &outputAttached, SecMonitorRef output, dispatch_queue_t phase2, dispatch_queue_t phase3);
+ SecTransformAttributeRef makeAH(transform_attribute *ta);
+
+public:
+
+ static CFTypeID GetCFTypeID();
+
+ // these functions are overloaded to implement the functionality of your transform
+ virtual ~Transform();
+
+ // this is called when one of your attributes (e.g. input) changes
+ virtual void AttributeChanged(SecTransformAttributeRef ah, CFTypeRef value);
+ // this is for backwards compatibility only (XXX: convert all existing Transform subclasses to not use it then remove)
+ virtual void AttributeChanged(CFStringRef name, CFTypeRef value);
+
+ // overload to return true if your transform can be externalized (generally true unless you are a monitor)
+ virtual bool IsExternalizable();
+
+ // Base implementation saves all attributes that have kSecTransformMetaAttributeExternalize TRUE (which is the default).
+ // If that isn't useful for your transform overload to return a CFDictionary that contains the state of
+ // your transform. Values returned should be serializable. Remember that this state will be restored
+ // before SecTransformExecute is called. Do not include the transform name in your state (this will be
+ // done for you by SecTransformCopyExternalRep).
+ virtual CFDictionaryRef CopyState();
+
+ // overload to restore the state of your transform
+ virtual void RestoreState(CFDictionaryRef state);
+ virtual void SetCustomExternalData(CFDictionaryRef customData);
+
+ virtual Boolean TransformCanExecute();
+ virtual CFErrorRef TransformStartingExecution();
+
+ SecTransformAttributeRef getAH(SecTransformStringOrAttributeRef attr, bool create_ok =true, bool create_undesrscore_ok =false);
+ CFArrayRef GetAllAH();
+
+ CFStringRef GetName();
+
+ // Output debugging information if the DEBUG attribute is set for this transform
+ void Debug(const char *fmt, ...);
+
+ CFErrorRef RefactorErrorToIncludeAbortingTransform(CFErrorRef sourceError);
+
+public:
+ CFErrorRef Connect(GroupTransform *group, Transform* destinationTransform, CFStringRef myKey, CFStringRef hisKey);
+ CFErrorRef Disconnect(Transform* destinationTransform, CFStringRef myKey, CFStringRef hisKey);
+
+ CFErrorRef ExternalSetAttribute(SecTransformStringOrAttributeRef key, CFTypeRef value);
+ CFErrorRef SetAttribute(SecTransformStringOrAttributeRef key, CFTypeRef value);
+ CFTypeRef GetAttribute(SecTransformStringOrAttributeRef key);
+ CFTypeRef GetMetaAttribute(SecTransformStringOrAttributeRef key, SecTransformMetaAttributeType type);
+
+ CFErrorRef Pushback(SecTransformAttributeRef ah, CFTypeRef value);
+
+ void Do(SecTransformAttributeRef name, CFTypeRef value);
+
+ CFTypeRef Execute(dispatch_queue_t deliveryQueue, SecMessageBlock deliveryBlock, CFErrorRef* errorRef);
+
+ // set to get notified every time this transform does something -- used for debugging
+ void SetActivityMonitor(ActivityMonitor am);
+
+ virtual CFDictionaryRef Externalize(CFErrorRef *error);
+
+ // Returns NULL if not in a group; can return this
+ GroupTransform* GetRootGroup();
+
+ friend class GroupTransform;
+ friend Transform::TransformOperation makeIdleOp(dispatch_group_t idle_group);
+
+ void SetGroup(GroupTransform* group) {mGroup = group;}
+ CFDictionaryRef GetCustomExternalData();
+};
+
+
+inline struct transform_attribute *ah2ta(SecTransformAttributeRef ah) {
+ // CF stores our data just after the CFRuntimeBase, we just have a single pointer there.
+ return *(struct transform_attribute **)(1 + (CFRuntimeBase*)ah);
+}
+
+#endif
projects / apple / security.git / blobdiff