1  /*
   2   * Copyright (c) 2010-2012,2014 Apple Inc. All Rights Reserved.
   3   *
   4   * @APPLE_LICENSE_HEADER_START@
   5   * 
   6   * This file contains Original Code and/or Modifications of Original Code
   7   * as defined in and that are subject to the Apple Public Source License
   8   * Version 2.0 (the 'License'). You may not use this file except in
   9   * compliance with the License. Please obtain a copy of the License at
  10   * http://www.opensource.apple.com/apsl/ and read it before using this
  11   * file.
  12   * 
  13   * The Original Code and all software distributed under the License are
  14   * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  15   * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  16   * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  17   * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  18   * Please see the License for the specific language governing rights and
  19   * limitations under the License.
  20   * 
  21   * @APPLE_LICENSE_HEADER_END@
  22   */
  23  
  24  
  25  #include "SecCustomTransform.h"
  26  #include "SecTransformValidator.h"
  27  
  28  #include "TransformFactory.h"
  29  #include <CoreFoundation/CoreFoundation.h>
  30  #include <Block.h>
  31  #include <syslog.h>
  32  #include "Utilities.h"
  33  #include "misc.h"
  34  
  35  const CFStringRef kSecCustom = CFSTR("CustomTransform");
  36  const CFStringRef kSecTransformPreviousErrorKey = CFSTR("PreviousError");
  37  const CFStringRef kSecTransformAbortOriginatorKey = CFSTR("Originating Transform");
  38  const CFStringRef kSecTransformActionCanExecute = CFSTR("CanExecute");
  39  const CFStringRef kSecTransformActionStartingExecution = CFSTR("ExecuteStarting");
  40  const CFStringRef kSecTransformActionProcessData = CFSTR("TransformProcessData");
  41  const CFStringRef kSecTransformActionAttributeNotification = CFSTR("GenericAttributeSetNotification");
  42  const CFStringRef kSecTransformActionFinalize = CFSTR("Finalize");
  43  const CFStringRef kSecTransformActionExternalizeExtraData = CFSTR("ExternalizeExtraData");
  44  const CFStringRef kSecTransformActionInternalizeExtraData = CFSTR("InternalizeExtraData");
  45  const CFStringRef kSecTransformActionAttributeValidation = CFSTR("AttributeValidation");
  46  
  47  /*!
  48  	@function		SecTransformOverrideTransformAction
  49  	
  50  	@abstract		Used to override the default behavior of a custom transform. 
  51  	
  52  	@param action	This should be either kSecTransformActionCanExecute, 
  53  					kSecTransformActionStartingExecution, or 
  54  					kSecTransformActionFinalize which signifies the behavior
  55  					that is being overridden.									
  56  					
  57  	@param newAction	
  58  					A SecTransformAttributeActionBlock block that implements the 
  59  					override behavior.  Please see the 
  60  					SecTransformActionBlock discussion for more 
  61  					information.
  62  				
  63  	@result			A CFErrorRef if an error occurred, NULL otherwise.
  64  					
  65  	@discussion		An action may be overridden more then once, the most
  66  					recent override will be used.Please see the example in 
  67  					the documentation for the SecTransformActionBlock 
  68  					block.
  69  					
  70  */
  71  typedef CFTypeRef (^SecTransformOverrideTransformAction)(CFStringRef action, 
  72  								SecTransformActionBlock newAction);
  73  								
  74  /*!
  75  	@function		SecTransformOverrideDataAction
  76  	
  77  	@abstract		Changes the default attribute handling for a 
  78  					specified attribute.
  79  					
  80  	@param action	This should be either kSecTransformActionProcessData, 
  81  					kSecTransformActionExternalizeExtraData which signifies  
  82  					what behavior is being overridden.
  83  															
  84  	@param newAction	 
  85  					A SecTransformDataBlock block that implements the 
  86  					override behavior. Please see the 
  87  					SecTransformDataBlock discussion for more 
  88  					information.
  89  
  90  	@result			A CFErrorRef if an error occurred. NULL otherwise.
  91  					
  92  	@discussion		An action may be overridden more then once, the most
  93  				    recent override will be used. Please see the example 
  94  					in the documentation for the SecTransformAttributeActionBlock 
  95  					block.
  96  				
  97  */
  98  typedef CFTypeRef (^SecTransformOverrideDataAction)(CFStringRef action, 
  99  								SecTransformDataBlock newAction);
 100  								
 101  /*!
 102  	@function		SecTransformOverrideAttributeAction
 103  	
 104  	@abstract		Changes the default attribute handling for a 
 105  					specified attribute.
 106  					
 107  	@param action	This should be either SecTransformSetAttributeAction, 
 108  					kSecTransformActionAttributeValidation which signifies  
 109  					what behavior is being overridden.
 110  	
 111  	@param attribute	
 112  					The attribute whose attribute default attribute handling is 
 113  					being overridden.  Passing NULL will override all attributes
 114  					that have not been specifically overridden.
 115  										
 116  	@param newAction	 
 117  					A SecTransformAttributeActionBlock block 
 118  					that implements the  override behavior. 
 119  					
 120  					If the action parameter is SecTransformSetAttributeAction
 121  					then this block is called whenever a set is called on the
 122  					attribute that this block was registered for or in the case
 123  					of a NULL attribute name any attribute that has not been specifically
 124  					overridden.  The block may transmogrify the data as needed.  It may
 125  					also send the data to any other attribue by calling 
 126  					SecTransformCustomSetAttribute.  The value returned from the block 
 127  					will be the new value for the attribute.
 128  					
 129  					If the action parameter is kSecTransformActionAttributeValidation then
 130  					this block is called to validate the new value for the
 131  					attribute that this block was registered for or in the case
 132  					of a NULL attribute name any attribute that has not been specifically
 133  					overridden.  The block should test if the new value is acceptable
 134  					and return NULL if it is valid a CFErrorRef otherwise.
 135  					
 136  	@result			A CFErrorRef if an error occurred. NULL otherwise.
 137  					
 138  	@discussion		An action may be overridden more then once, the most
 139  				    recent override will be used. Please see the example 
 140  					in the documentation for the 
 141  					SecTransformAttributeActionBlock block.
 142  				
 143  */
 144  typedef CFTypeRef (^SecTransformOverrideAttributeAction)( 
 145  								CFStringRef action,
 146  								SecTransformStringOrAttributeRef attribute, 
 147  								SecTransformAttributeActionBlock newAction);
 148  
 149  								
 150  /*!
 151  	@function		SecTransformGetAttributeBlock
 152  	
 153  	@abstract		Retrieves the value of the attribute metadata of the 
 154  					type specified.
 155  					
 156  	@param attribute	
 157  					The attribute from which to retrieve the metadata from.
 158  					
 159  	@param type		The type of the metadata to be fetched.
 160  						
 161  	@result			The value of the metadata that was retrieved or a CFErrorRef
 162  					if an error occurred
 163  	
 164  	@result 		The value of the metadata that was retrieved.
 165  	
 166  
 167  */
 168  typedef CFTypeRef (^SecTransformGetAttributeBlock)(
 169  										SecTransformStringOrAttributeRef attribute, 
 170  										SecTransformMetaAttributeType type);
 171  										
 172  /*!
 173  	@function		SecTransformSetAttributeBlock
 174  	
 175  	@abstract		This sets the value of the metadata of an attribute.  
 176  		
 177  	@param attribute	
 178  					The attribute whose value is sent
 179  					
 180  	@param type		The metadata type that specifies what metadata value
 181  					is set.
 182  					
 183  	@param value	The value of the metadata to be sent.
 184  						
 185  	@result			A CFErrorRef is an error occurred, NULL otherwise.
 186  	
 187  	@discussion		The attribute parameter specifies which attribute will 
 188  					have its data set. The type parameter specifies which of 
 189  					the metadata items is set. The value parameter is the 
 190  					new metadata value.
 191  							
 192  */
 193  typedef CFErrorRef (^SecTransformSetAttributeBlock)(
 194  	SecTransformStringOrAttributeRef attribute, 
 195  	SecTransformMetaAttributeType type, 
 196  	CFTypeRef value);
 197  	
 198  
 199  /*!
 200  	@function		SecTransformPushBackAttributeBlock
 201  
 202  	@abstract		Allows for putting a single value back for a 
 203  					specific attribute.  This will stop the flow of
 204  					data into the specified attribute until an
 205  					attribute is changed.
 206  
 207  	@param attribute	
 208  					The attribute that has its data pushed back.
 209  
 210  	@param value	The value being pushed back.
 211  
 212  
 213  	@result			A CFErrorRef is an error occurred, NULL otherwise.
 214  					Note: pushing back a second value will abort the
 215  					transform, not return an error from this call.
 216  
 217  	@discussion		A particular custom transform may need multple
 218  					values to be set before it can do the processing
 219  					that the custom transform is designed to do. For
 220  					example, it may need a key and a salt value.  The
 221  					salt value maybe supplied by another transform while
 222  					the key transform may have been set explicitly.  When
 223  					data is presented to this custom transform the salt
 224  					value may not have been sent from the upstream transform.
 225  					The custom transform can then push back the input data
 226  					which causes the transform to stall.  When any 
 227  					attribute on the custom transform is changed, such as 
 228  					the upstream transform delivers the salt value, then 
 229  					the data that was pushed back is re-delivered
 230  
 231  */
 232  typedef CFErrorRef (^SecTransformPushBackAttributeBlock)(
 233  										SecTransformStringOrAttributeRef attribute, 
 234  										CFTypeRef value);
 235  
 236  /*!
 237  	@const kSecTransformCreateBlockParametersVersion
 238  			The current version number of the SecTransformCreateBlockParameters
 239  			struct
 240  	
 241  */
 242  enum 
 243  {
 244  	kSecTransformCreateBlockParametersVersion = 1
 245  };
 246  
 247  extern "C" {
 248  	Boolean SecExternalSourceSetValue(SecTransformRef xst, CFTypeRef value, CFErrorRef *error);
 249  }
 250  
 251  /*!
 252  	@struct OpaqueSecTransformImplementation
 253  	
 254  	@field version
 255  			The version number of this structure
 256  			
 257  	@field overrideTransform
 258  			A SecTransformOverrideTransformAction block.  See
 259  			the headerdoc for this block for additional information.
 260  			
 261  	@field overrideAttribute
 262  			A SecTransformOverrideAttributeAction block. See
 263  			the headerdoc for this block for additional information.
 264  
 265  	@field get
 266  			A SecTransformGetAttributeBlock block. See
 267  			the headerdoc for this block for additional information.
 268  			
 269  	@field send
 270  		A SecTransformSetAttributeBlock block.  See
 271  		the headerdoc for this block for additional information.
 272  		
 273  	@field pushback
 274  		A SecTransformPushBackAttributeBlock block. See
 275  		the headerdoc for this block for additional information.
 276  */
 277  struct OpaqueSecTransformImplementation
 278  {
 279  	CFIndex version;	// Set to kSecTransformCreateBlockParametersVersion
 280  	
 281  	// The following two blocks allow for overriding 'standard' 
 282  	// transform behavior
 283  	SecTransformOverrideTransformAction overrideTransform;
 284  	SecTransformOverrideDataAction overrideData;
 285  	SecTransformOverrideAttributeAction overrideAttribute;
 286  	
 287  	// The following methods allow for dealing with the transform mechanism
 288  	// They are called synchronously
 289  	SecTransformGetAttributeBlock get;
 290  	SecTransformSetAttributeBlock send;
 291  	SecTransformPushBackAttributeBlock pushback;
 292  };
 293  
 294  										
 295  class CustomTransformFactory : public TransformFactory 
 296  {
 297  protected:
 298  	SecTransformCreateFP  createFuncPtr;
 299  public:
 300  	CustomTransformFactory(CFStringRef name, SecTransformCreateFP createFP, CFErrorRef *error);
 301      virtual ~CustomTransformFactory() {};
 302  	virtual CFTypeRef Make();
 303  };
 304  
 305  
 306  static const SecTransformActionBlock default_can_run = ^{ return (CFTypeRef)NULL; };
 307  static const SecTransformActionBlock default_execute_starting = default_can_run;
 308  static const SecTransformActionBlock default_finalize = default_execute_starting;
 309  static const SecTransformActionBlock default_externalize_data = default_finalize;
 310  
 311  static const SecTransformDataBlock default_process_data = ^(CFTypeRef value) { return value; };
 312  //static SecTransformDataBlock default_validate = ^(CFTypeRef value) { return (CFTypeRef)NULL; };
 313  static const SecTransformAttributeActionBlock default_generic_attribute_set_notification =
 314  	^(SecTransformAttributeRef ah, CFTypeRef value) { return value; };
 315  
 316  static SecTransformAttributeActionBlock default_generic_attribute_validation = 
 317  ^(SecTransformAttributeRef ah, CFTypeRef value) 
 318  {
 319  	 return (CFTypeRef)NULL;
 320  };
 321  
 322  static SecTransformDataBlock default_internalize_data = 
 323  			^(CFTypeRef value) 
 324  { 
 325  	return (CFTypeRef)NULL; 
 326  };
 327  
 328  class CustomTransform : public Transform 
 329  {
 330  protected:
 331  	SecTransformCreateFP					createFuncPtr;
 332  	SecTransformInstanceBlock			instanceBlock;	  
 333  			
 334  	SecTransformActionBlock 			can_run;
 335  	SecTransformActionBlock 			execute_starting;
 336  	SecTransformActionBlock 			finalize;
 337  	SecTransformAttributeActionBlock 	generic_attribute_set_notification;
 338  	SecTransformAttributeActionBlock	generic_attribute_validation;
 339  	SecTransformDataBlock 				process_data;
 340  	SecTransformActionBlock 			externalize_data;
 341  	SecTransformDataBlock 				internalize_data;
 342  		
 343  	SecTransformRef tr;	
 344  	
 345  	SecTransformAttributeRef 			input_ah;
 346  	SecTransformAttributeRef			output_ah;
 347  	
 348  	OpaqueSecTransformImplementation parameters;
 349  	
 350  	void SetCanExecute(SecTransformActionBlock CanExecuteBlock)
 351  	{
 352  		Block_release(can_run);
 353  		if (CanExecuteBlock)
 354  		{
 355  			can_run = Block_copy(CanExecuteBlock);
 356  			
 357  		}
 358  		else
 359  		{
 360  			can_run	 = Block_copy(default_can_run);
 361  		}
 362  	}
 363  	
 364  	void SetExecuteStarting(SecTransformActionBlock executeStartingBlock)
 365  	{
 366  		Block_release(execute_starting);
 367  		if (executeStartingBlock)
 368  		{
 369  			execute_starting = Block_copy(executeStartingBlock);
 370  			
 371  		}
 372  		else
 373  		{
 374  			execute_starting = Block_copy(default_execute_starting);
 375  		}
 376  	}
 377  	
 378  	void SetFinalize(SecTransformActionBlock finalizeBlock)
 379  	{
 380  		Block_release(finalize);
 381  		if (finalizeBlock)
 382  		{
 383  			finalize = Block_copy(finalizeBlock);
 384  			
 385  		}
 386  		else
 387  		{
 388  			finalize = Block_copy(default_finalize);
 389  		}
 390  	}
 391  	
 392  	void SetExternalizeExtraData(SecTransformActionBlock externalizeBlock)
 393  	{
 394  		Block_release(externalizeBlock);
 395  		if (externalizeBlock)
 396  		{
 397  			externalize_data = Block_copy(externalizeBlock);
 398  			
 399  		}
 400  		else
 401  		{
 402  			externalize_data = Block_copy(default_externalize_data);
 403  		}
 404  	}
 405  	
 406  	void SetProcessData(SecTransformDataBlock processDataBlock)
 407  	{
 408  		Block_release(process_data);
 409  		if (processDataBlock)
 410  		{
 411  			process_data = Block_copy(processDataBlock);
 412  			
 413  		}
 414  		else
 415  		{
 416  			process_data = Block_copy(default_process_data);
 417  		}
 418  	}
 419  	
 420  	void SetInternalizeExtraData(SecTransformDataBlock InternalizeExtraDataBlock)
 421  	{
 422  		Block_release(internalize_data);
 423  		if (InternalizeExtraDataBlock)
 424  		{
 425  			internalize_data = Block_copy(InternalizeExtraDataBlock);
 426  			
 427  		}
 428  		else
 429  		{
 430  			internalize_data = Block_copy(default_internalize_data);
 431  		}
 432  	}
 433  	
 434  	
 435  		
 436  	void SetNotficationBlock(SecTransformStringOrAttributeRef attribute, 
 437  							SecTransformAttributeActionBlock notificationBlock)
 438  	{
 439  		SecTransformAttributeActionBlock blockToSet = 
 440  			Block_copy((notificationBlock) ? notificationBlock : 
 441  				   default_generic_attribute_set_notification);
 442  		
 443  		if (attribute)
 444  		{
 445  			transform_attribute *ta = getTA(attribute, true);
 446  			
 447  			if (ta->attribute_changed_block) 
 448  			{
 449  				Block_release(ta->attribute_changed_block);
 450  			}
 451  			
 452  			ta->attribute_changed_block = blockToSet;
 453  		}
 454  		else		
 455  		{	
 456  			
 457  			if (generic_attribute_set_notification) 
 458  			{
 459  				Block_release(generic_attribute_set_notification);
 460  			}
 461  			
 462  			generic_attribute_set_notification = blockToSet;			
 463  		}
 464  	}
 465  
 466  	void SetVerifyBlock(SecTransformStringOrAttributeRef attribute, 
 467  							SecTransformAttributeActionBlock verifyBlock)
 468  	{
 469  		SecTransformAttributeActionBlock blockToSet = 
 470  			Block_copy((verifyBlock) ? verifyBlock : 
 471  				   generic_attribute_validation);
 472  		
 473  		if (attribute)
 474  		{
 475  			transform_attribute *ta = getTA(attribute, true);
 476  			
 477  			if (ta->attribute_validate_block) 
 478  			{
 479  				Block_release(ta->attribute_validate_block);
 480  			}
 481  			
 482  			ta->attribute_validate_block = blockToSet;
 483  		}
 484  		else		
 485  		{	
 486  			if (generic_attribute_validation) 
 487  			{
 488  				Block_release(generic_attribute_validation);
 489  			}
 490  			
 491  			generic_attribute_validation = blockToSet;			
 492  		}
 493  	}
 494  		
 495  		
 496  
 497  public:
 498  	CustomTransform(CFStringRef name, SecTransformCreateFP createFP);
 499  	virtual ~CustomTransform();
 500  	
 501  	void Create();
 502  	
 503  	CFTypeRef rebind_data_action(CFStringRef action, 
 504  		SecTransformDataBlock new_action);
 505  		
 506  	CFTypeRef rebind_transform_action(CFStringRef action, SecTransformActionBlock new_action);
 507  	
 508  	CFTypeRef rebind_attribute_action(CFStringRef action,
 509  							SecTransformStringOrAttributeRef attribute, 
 510  							SecTransformAttributeActionBlock new_action);
 511  	
 512  	SecTransformRef get_ref() { return tr; }
 513  	
 514  	virtual void AttributeChanged(CFStringRef name, CFTypeRef value);
 515  	virtual void AttributeChanged(SecTransformAttributeRef ah, CFTypeRef value);
 516  	virtual CFErrorRef TransformStartingExecution();
 517  	virtual CFDictionaryRef GetCustomExternalData();
 518  	virtual void SetCustomExternalData(CFDictionaryRef customData);
 519  	
 520  	friend Boolean SecExternalSourceSetValue(SecTransformRef xst, CFTypeRef value, CFErrorRef *error);
 521  };
 522  
 523  
 524  
 525  #pragma mark CustomTransformFactory
 526  
 527  CustomTransformFactory::CustomTransformFactory(CFStringRef uniqueName, SecTransformCreateFP createFP, CFErrorRef* error) : 
 528  	TransformFactory(uniqueName, false, kSecCustom), 
 529  	createFuncPtr(createFP) 
 530  {
 531  	TransformFactory *existing = FindTransformFactoryByType(uniqueName);
 532  	if (existing) 
 533  	{
 534  		if (error) 
 535  		{
 536  			*error = CreateSecTransformErrorRef(kSecTransformErrorNameAlreadyRegistered, 
 537  				"Custom transform type %s already exists.", uniqueName);
 538  		}
 539          return;
 540  	}
 541  	
 542      
 543      if (CFStringGetCharacterAtIndex(uniqueName, 0) == '_')
 544      {
 545          if (error)
 546          {
 547              *error = CreateSecTransformErrorRef(kSecTransformInvalidArgument, 
 548                                                  "Invalid transform type name %s -- type names must not start with an _", uniqueName);
 549          }
 550          return;
 551      }
 552      
 553      static CFCharacterSetRef invalidTypeCharactors = NULL;
 554      static dispatch_once_t setupInvalidTypeCharactors;
 555      dispatch_once(&setupInvalidTypeCharactors, ^{
 556          invalidTypeCharactors = CFCharacterSetCreateWithCharactersInString(NULL, CFSTR("/:"));
 557      });
 558      CFRange has_bad;
 559      if (CFStringFindCharacterFromSet(uniqueName, invalidTypeCharactors, CFRangeMake(0, CFStringGetLength(uniqueName)), 0, &has_bad)) {
 560          if (error)
 561          {
 562              *error = CreateSecTransformErrorRef(kSecTransformInvalidArgument, 
 563                                              "Invalid character '%c' in transform type name %s", CFStringGetCharacterAtIndex(uniqueName, has_bad.location), uniqueName);
 564          }
 565          return;
 566      }
 567      RegisterTransform(this, kSecCustom);
 568  }
 569  
 570  // clang cannot possibly reason about the way in which we turn Transforms into CFRefs, and it just looks like a leak
 571  #ifndef __clang_analyzer__
 572  CFTypeRef CustomTransformFactory::Make() CF_RETURNS_RETAINED
 573  {
 574  	CustomTransform *ct = new CustomTransform(this->GetTypename(), createFuncPtr);
 575  	ct->Create();
 576  	return ct->get_ref();
 577  }
 578  #endif
 579  
 580  #pragma mark MISC
 581  
 582  extern "C" {
 583  	SecTransformAttributeActionBlock SecTransformCreateValidatorForCFtype(CFTypeID expected_type, Boolean null_allowed) {
 584  		SecTransformAttributeActionBlock validate = NULL;
 585  		CFErrorRef (^make_error_message)(SecTransformAttributeRef attr, CFTypeRef value, CFTypeID expected_type, Boolean null_allowed) = 
 586  		^(SecTransformAttributeRef attr, CFTypeRef value, CFTypeID expected_type, Boolean null_allowed) {
 587  			CFStringRef expected_type_name = CFCopyTypeIDDescription(expected_type);
 588  			CFErrorRef error = NULL;
 589  			if (value) {
 590  				CFStringRef value_type_name = CFCopyTypeIDDescription(CFGetTypeID(value));
 591  				error = CreateSecTransformErrorRef(kSecTransformErrorInvalidType, "%@ received value of type %@ (%@), expected%@ a %@%@",
 592  															  attr, value_type_name, value,
 593  															  null_allowed ? CFSTR(" either") : CFSTR(""),
 594  															  expected_type_name,
 595  															  null_allowed ? CFSTR(" or a NULL") : CFSTR(""));
 596  				CFReleaseNull(value_type_name);
 597  			} else {
 598  				error = CreateSecTransformErrorRef(kSecTransformErrorInvalidType, "%@ received NULL value, expected a %@",
 599  												   attr, expected_type_name);
 600  			}
 601  			CFReleaseNull(expected_type_name);
 602  			
 603  			return error;
 604  		};
 605  		
 606  		
 607  		if (null_allowed) {
 608  			validate = ^(SecTransformAttributeRef attr, CFTypeRef value) {
 609  				if (value == NULL || CFGetTypeID(value) == expected_type) {
 610  					return (CFTypeRef)NULL;
 611  				}
 612  				return (CFTypeRef)make_error_message(attr, value, expected_type, null_allowed);
 613  			};
 614  		} else {
 615  			validate = ^(SecTransformAttributeRef attr, CFTypeRef value) {
 616  				if (value != NULL && CFGetTypeID(value) == expected_type) {
 617  					return (CFTypeRef)NULL;
 618  				}
 619  				return (CFTypeRef)make_error_message(attr, value, expected_type, null_allowed);
 620  			};
 621  		}
 622  		
 623  		return Block_copy(validate);
 624  	}
 625  }
 626  
 627  // clang cannot reason about this business of creating an object for the side-effects of doing so
 628  #ifndef __clang_analyzer__
 629  Boolean SecTransformRegister(CFStringRef uniqueName, SecTransformCreateFP createFP, CFErrorRef *caller_error) 
 630  {
 631  	CFErrorRef error = NULL;
 632  	
 633  	CustomTransformFactory *tf = new CustomTransformFactory(uniqueName, createFP, &error);
 634  	if (error) 
 635  	{
 636  		delete tf;
 637  		if (caller_error) 
 638  		{
 639  			*caller_error = error;
 640  		}
 641  		return FALSE;
 642  	} 
 643  	else 
 644  	{
 645  		return TRUE;
 646  	}
 647  }
 648  #endif
 649  
 650  SecTransformRef SecTransformCreate(CFStringRef name, CFErrorRef *error) 
 651  {
 652  	SecTransformRef tr = TransformFactory::MakeTransformWithType(name, error);
 653  	return tr;
 654  }
 655  
 656  extern "C" {
 657  	Boolean SecExternalSourceSetValue(SecTransformRef xst, CFTypeRef value, CFErrorRef *error)
 658  	{
 659  		CustomTransform *ct = (CustomTransform *)CoreFoundationHolder::ObjectFromCFType(xst);
 660  		extern CFStringRef external_source_name;
 661  		if (CFEqual(ct->mTypeName, external_source_name)) {
 662  			ct->SetAttribute(ct->input_ah, value);
 663  			return true;
 664  		} else {
 665  			if (error) {
 666  				*error = CreateSecTransformErrorRef(kSecTransformErrorInvalidType, "SecExternalSourceSetValue called for %@, you need to pass in an ExternalSource transform not a %@", ct->GetName(), ct->mTypeName);
 667  			}
 668  			return false;
 669  		}
 670  	}
 671  }
 672  
 673  /* ==========================================================================
 674  	class:			NoDataClass
 675  	description:	A Special CFType that signifies that no data is being 
 676  					returned
 677     ==========================================================================*/
 678  #pragma mark NoDataClass
 679  
 680  class NoDataClass : public CoreFoundationObject
 681  {
 682  protected:
 683  	NoDataClass();
 684  
 685  public:
 686  	virtual ~NoDataClass();
 687  	std::string FormattingDescription(CFDictionaryRef options);
 688  	std::string DebugDescription();
 689  	static CFTypeRef Make();
 690  };
 691  
 692  CFTypeRef NoDataClass::Make() {
 693  	NoDataClass* obj = new NoDataClass();
 694  	return CoreFoundationHolder::MakeHolder(gInternalProtectedCFObjectName, obj);
 695  }
 696  
 697  
 698  NoDataClass::NoDataClass() : CoreFoundationObject(gInternalProtectedCFObjectName) {
 699  }
 700  
 701  NoDataClass::~NoDataClass()
 702  {
 703  }
 704  
 705  std::string NoDataClass::DebugDescription() 
 706  {
 707  	return CoreFoundationObject::DebugDescription() + " | SecTransformNoData";
 708  }
 709  
 710  std::string NoDataClass::FormattingDescription(CFDictionaryRef options) 
 711  {
 712  	return CoreFoundationObject::FormattingDescription(options) + " | SecTransformNoData";
 713  }
 714  
 715  CFTypeRef SecTransformNoData() 
 716  {
 717  	static dispatch_once_t inited;
 718  	static CFTypeRef no_data;
 719  	
 720  	dispatch_once(&inited, 
 721  	^{
 722  		no_data = NoDataClass::Make();
 723  	});
 724  	
 725  	return no_data;
 726  }
 727  
 728  /* ==========================================================================
 729  	class Implementation	CustomTransform	
 730     ==========================================================================*/
 731  
 732  #pragma mark CustomTransform
 733  
 734  void CustomTransform::AttributeChanged(CFStringRef name, CFTypeRef value) {
 735  #ifndef NDEBUG
 736  	// We really shouldn't get here, and this is the debug build so we can blow up on the spot so it is easy to look at the stack trace
 737  	abort();
 738  #else
 739  	// We really shouldn't get here, but this is a production build and recovery is easy to code (but costly to execute)
 740  	AttributeChanged(getAH(name, false), value);
 741  #endif
 742  }
 743  
 744  void CustomTransform::AttributeChanged(SecTransformAttributeRef ah, CFTypeRef value) 
 745  {
 746  	transform_attribute *ta = ah2ta(ah);
 747  	SecTransformAttributeActionBlock attribute_set_notification = NULL;
 748  
 749  	SecTransformAttributeActionBlock attribute_validate = NULL;
 750  
 751  	attribute_validate = (SecTransformAttributeActionBlock)ta->attribute_validate_block;
 752  	if (!attribute_validate) {
 753  			attribute_validate = generic_attribute_validation;
 754  	}
 755  	CFTypeRef vr = attribute_validate(ah, value);
 756  	if (vr) {
 757  			if (CFGetTypeID(vr) == CFErrorGetTypeID()) {
 758  					SendAttribute(AbortAH, vr);
 759  					CFReleaseNull(vr);
 760  			} else {
 761                      CFStringRef idDescription = CFCopyTypeIDDescription(CFGetTypeID(vr));
 762  					CFErrorRef e = CreateSecTransformErrorRef(kSecTransformErrorInvalidType, "Invalid return type from a validate action, expected a CFErrorRef got a %@ (%@)", idDescription, vr);
 763  					SendAttribute(AbortAH, e);
 764  					CFReleaseNull(vr);
 765                      CFReleaseNull(e);
 766                      CFReleaseNull(idDescription);
 767  					// XXX: this causes a core dump -- I think AbortAH doesn't take it's own reference!!   CFReleaseNull(e);
 768  			}
 769  			return;
 770  	}
 771  
 772  	attribute_set_notification = (SecTransformAttributeActionBlock)ta->attribute_changed_block;
 773  
 774  	if ((!attribute_set_notification) && ah == input_ah) 
 775  	{
 776  		CFTypeID vtype = value ? CFGetTypeID(value) : CFDataGetTypeID();
 777  		if (vtype == CFDataGetTypeID()) 
 778  		{
 779  			CFTypeRef output = process_data(value);
 780  			if (output == NULL || output != SecTransformNoData()) 
 781  			{
 782  				SendAttribute(output_ah, output);
 783  
 784                  // if output == value, we are being asked to just
 785                  // forward the existing value.  No need to release.
 786                  // If they are different, we are being asked to
 787                  // send a new value which must be released.
 788  
 789                  if (output != value && output != NULL)
 790                  {
 791                      CFReleaseNull(output);
 792                  }
 793  			}
 794  		} 
 795  		else if (vtype == CFErrorGetTypeID() && !ah2ta(ah)->direct_error_handling) 
 796  		{
 797  			SendAttribute(output_ah, value);
 798  		} else 
 799  		{
 800  			attribute_set_notification = attribute_set_notification ? attribute_set_notification : generic_attribute_set_notification;
 801  			CFTypeRef new_value = attribute_set_notification(ah, value);
 802  			if (new_value != value) 
 803  			{
 804  				SendAttribute(ah, new_value);
 805  			}
 806  		}
 807  	} 
 808  	else 
 809  	{
 810  		CFTypeID vtype = value ? CFGetTypeID(value) : CFDataGetTypeID();
 811  		if (vtype != CFErrorGetTypeID() || ah2ta(ah)->direct_error_handling) 
 812  		{
 813  			attribute_set_notification = attribute_set_notification ? attribute_set_notification : generic_attribute_set_notification;
 814  			CFTypeRef new_value = attribute_set_notification(ah, value);
 815  			if (new_value != value) 
 816  			{
 817  				SendAttribute(ah, new_value);
 818  			}
 819  		} 
 820  		else 
 821  		{
 822  			SendAttribute(output_ah, value);
 823  		}
 824  	}
 825  }
 826  
 827  CFTypeRef CustomTransform::rebind_data_action(CFStringRef action, 
 828  			SecTransformDataBlock new_action) 
 829  {
 830  	CFTypeRef result = NULL;
 831  	if (kCFCompareEqualTo == CFStringCompare(kSecTransformActionProcessData, action, 0)) 
 832  	{
 833  		SetProcessData(new_action);
 834  	}
 835  	else if (kCFCompareEqualTo == CFStringCompare(kSecTransformActionInternalizeExtraData, action, 0))
 836  	{
 837  		SetInternalizeExtraData(new_action);
 838  	}
 839  	else 
 840  	{
 841  		result = (CFTypeRef)CreateSecTransformErrorRef(kSecTransformInvalidOverride, "Unkown override type");
 842  
 843          // XXX: can we get a stackdump here too?
 844          CFStringRef msg = CFStringCreateWithFormat(NULL, NULL,
 845                                                     CFSTR("rebind_data_action (action %@, new_action %p, transform %s)"),
 846                                                     action, (void*)new_action, DebugDescription().c_str());
 847          char *utf8_message = utf8(msg);
 848          syslog(LOG_ERR, "%s", utf8_message);
 849          free(utf8_message);
 850          CFReleaseNull(msg);
 851  	}
 852  	return result;
 853  }
 854  
 855  CFTypeRef CustomTransform::rebind_transform_action(CFStringRef action, SecTransformActionBlock new_action) 
 856  {
 857  	CFErrorRef result = NULL;
 858  	
 859  	if (kCFCompareEqualTo == CFStringCompare(action, kSecTransformActionCanExecute, 0)) 
 860  	{
 861  		SetCanExecute(new_action);
 862  	}
 863  	else if (kCFCompareEqualTo == CFStringCompare(action, kSecTransformActionStartingExecution, 0)) 
 864  	{
 865  		SetExecuteStarting(new_action);
 866  	}
 867  	else if (kCFCompareEqualTo == CFStringCompare(action, kSecTransformActionFinalize, 0))
 868  	{
 869  		SetFinalize(new_action);
 870  	}
 871  	else if (kCFCompareEqualTo == CFStringCompare(action, kSecTransformActionExternalizeExtraData, 0))
 872  	{
 873  		SetExternalizeExtraData(new_action);
 874  	}
 875  	else
 876  	{
 877  		result = CreateSecTransformErrorRef(kSecTransformInvalidOverride, "Unkown override type");
 878  
 879  		char *action_utf8 = utf8(action);
 880  		syslog(LOG_ERR, "rebind_transform_action (action %s, all-attributes, block %p, transform %s)\n", action_utf8, (void*)new_action, DebugDescription().c_str());
 881  		free(action_utf8);
 882  	}
 883  		
 884  	return result;
 885  }
 886  
 887  CFTypeRef CustomTransform::rebind_attribute_action(
 888  			CFStringRef action,
 889  			SecTransformStringOrAttributeRef attribute, 
 890  			SecTransformAttributeActionBlock new_action) 
 891  {
 892  	CFErrorRef result = NULL;
 893  	
 894  	if (kCFCompareEqualTo == CFStringCompare(action, kSecTransformActionAttributeNotification, 0)) 
 895  	{
 896  		SetNotficationBlock(attribute, new_action);
 897  	}
 898  	else if (kCFCompareEqualTo == CFStringCompare(action, kSecTransformActionAttributeValidation, 0))
 899  	{
 900  		SetVerifyBlock(attribute, new_action);
 901  	}
 902  	else
 903  	{
 904  		result = CreateSecTransformErrorRef(kSecTransformInvalidOverride, "Unkown override type");
 905  		char *action_utf8 = utf8(action);
 906  		syslog(LOG_ERR, "rebind_attribute_action (action %s, all-attributes, block %p, transform %s)\n", action_utf8, (void*)new_action, DebugDescription().c_str());
 907  		free(action_utf8);
 908  	}
 909  	
 910  	return result;	
 911  }
 912  
 913  CustomTransform::CustomTransform(CFStringRef cfname, SecTransformCreateFP createFP) : 
 914  	Transform(cfname), 
 915  	createFuncPtr(createFP), 
 916  	instanceBlock(NULL),
 917  	can_run(Block_copy(default_can_run)), 
 918  	execute_starting(Block_copy(default_execute_starting)), 
 919  	finalize(Block_copy(default_finalize)), 
 920  	generic_attribute_set_notification(Block_copy(default_generic_attribute_set_notification)),
 921  	generic_attribute_validation(Block_copy(default_generic_attribute_validation)),
 922  	process_data(Block_copy(default_process_data)),
 923  	externalize_data(Block_copy(default_externalize_data)),
 924  	internalize_data(Block_copy(default_internalize_data))
 925  {
 926  	mAlwaysSelfNotify = true;
 927  	
 928  	input_ah = getAH(kSecTransformInputAttributeName, true);
 929  	output_ah = getAH(kSecTransformOutputAttributeName, true);
 930  	
 931  	parameters.version = kSecTransformCreateBlockParametersVersion;
 932  	parameters.send = Block_copy(^(SecTransformStringOrAttributeRef attribute, SecTransformMetaAttributeType type, CFTypeRef value) 
 933  	{ 
 934  		return SendMetaAttribute(attribute, type, value); 
 935  	});
 936  	
 937  	parameters.pushback = Block_copy(^(SecTransformStringOrAttributeRef attribute, CFTypeRef value) 
 938  	{ 
 939  		return Pushback(getAH(attribute), value); 
 940  	});
 941  	
 942  	parameters.get = Block_copy(^(SecTransformStringOrAttributeRef attribute, SecTransformMetaAttributeType type) 
 943  	{ 
 944  		return GetMetaAttribute(attribute, type); 
 945  	});
 946  	
 947  	parameters.overrideTransform = Block_copy(^(CFStringRef action, SecTransformActionBlock new_action) 
 948  	{ 
 949  		return rebind_transform_action(action, new_action); 
 950  	});
 951  	
 952  	parameters.overrideData = Block_copy(^(CFStringRef action, 
 953  								SecTransformDataBlock new_action)
 954  	{
 955  		return rebind_data_action(action, new_action); 
 956  	});
 957  	
 958  	/*
 959  	 CFTypeRef (^SecTransformOverrideAttributeAction)( 
 960  	 CFStringRef action,
 961  	 SecTransformStringOrAttributeRef attribute, 
 962  	 SecTransformAttributeActionBlock newAction);
 963  	*/
 964  	parameters.overrideAttribute = 
 965  		Block_copy(^(CFStringRef action, SecTransformStringOrAttributeRef attribute, SecTransformAttributeActionBlock new_action) 
 966  	{ 
 967  		return rebind_attribute_action(action, attribute, new_action); 
 968  	});
 969  	
 970  	char *tname = const_cast<char*>(CFStringGetCStringPtr(cfname, kCFStringEncodingUTF8));
 971  	if (!tname) {
 972  		CFIndex sz = CFStringGetMaximumSizeForEncoding(CFStringGetLength(cfname), kCFStringEncodingUTF8);
 973  		tname = static_cast<typeof(tname)>(alloca(sz));
 974  		CFStringGetCString(cfname, tname, sz, kCFStringEncodingUTF8);
 975  	}	
 976  	tr = CoreFoundationHolder::MakeHolder(kSecCustom, (CoreFoundationObject*)this);
 977  	
 978  	instanceBlock = (*createFuncPtr)(cfname, tr, &parameters);
 979  }
 980  
 981  void CustomTransform::Create()
 982  {
 983  	(void)instanceBlock();
 984  }
 985  
 986  
 987  CustomTransform::~CustomTransform() {
 988  	finalize();
 989  	
 990  	if (instanceBlock)
 991  	{
 992  		Block_release(instanceBlock);
 993  	}
 994  	
 995  	Block_release(can_run);
 996  	Block_release(execute_starting);
 997  	Block_release(finalize);
 998  	Block_release(generic_attribute_set_notification);
 999  	Block_release(process_data);
1000  	Block_release(externalize_data);
1001  	Block_release(internalize_data);
1002  
1003  	Block_release(parameters.send);
1004  	Block_release(parameters.pushback);
1005  	Block_release(parameters.get);
1006  	Block_release(parameters.overrideTransform);
1007  	Block_release(parameters.overrideData);
1008  	Block_release(parameters.overrideAttribute);
1009  	
1010  	// strictly speaking this isn't needed, but it can help track down some "use after free" bugs
1011  	tr = NULL;
1012  	createFuncPtr = NULL;
1013  	process_data = NULL;
1014  }
1015  
1016  CFErrorRef CustomTransform::TransformStartingExecution() 
1017  {
1018  	CFTypeRef result = execute_starting();
1019  	return (CFErrorRef)result;
1020  }
1021  
1022  
1023  CFDictionaryRef CustomTransform::GetCustomExternalData()
1024  {
1025  	CFTypeRef result = externalize_data();
1026  	if (NULL == result)
1027  	{
1028  		return NULL;
1029  	}
1030  	
1031  	if (CFGetTypeID(result) == CFErrorGetTypeID())
1032  	{
1033  		// Ouch!  we should deal with this
1034  		CFReleaseNull(result);
1035  		return NULL;
1036  	}
1037  	
1038  	if (CFGetTypeID(result) == CFDictionaryGetTypeID())
1039  	{
1040  		return (CFDictionaryRef)result;
1041  	}
1042  	
1043  	CFReleaseNull(result);
1044  	result = NULL;
1045  	return (CFDictionaryRef)result;
1046  }
1047  
1048  
1049  void CustomTransform::SetCustomExternalData(CFDictionaryRef customData)
1050  {
1051  	if (NULL != customData)
1052  	{
1053  		internalize_data(customData);		
1054  	}
1055  	return;
1056  }
1057  
1058  CFErrorRef SecTransformSetAttributeAction(SecTransformImplementationRef ref, 
1059  								CFStringRef action,
1060  								SecTransformStringOrAttributeRef attribute, 
1061  								SecTransformAttributeActionBlock newAction)								
1062  {
1063  	if (NULL == ref)
1064  	{
1065          CFErrorRef result = CreateSecTransformErrorRef(kSecTransformErrorInvalidInput,
1066  			"SecTransformSetAttributeNotificationAction called with a NULL SecTransformImplementationRef ref");
1067          CFAutorelease(result);
1068  		return result;
1069  	}
1070  	
1071  	return (CFErrorRef)ref->overrideAttribute(action, attribute, newAction);
1072  }
1073  
1074  CFErrorRef SecTransformSetDataAction(SecTransformImplementationRef ref, 
1075  									CFStringRef action, 
1076  									SecTransformDataBlock newAction)
1077  {
1078  	if (NULL == ref)
1079  	{
1080          CFErrorRef result = CreateSecTransformErrorRef(kSecTransformErrorInvalidInput,
1081  			"SecTransformSetAttributeNotificationAction called with a NULL SecTransformImplementationRef ref");
1082          CFAutorelease(result);
1083  		return result;
1084  	}
1085  	
1086  	return (CFErrorRef)ref->overrideData(action, newAction);	
1087  }
1088  
1089  CFErrorRef SecTransformSetTransformAction(SecTransformImplementationRef ref,
1090  								CFStringRef action, 
1091  								SecTransformActionBlock newAction)
1092  {
1093  	if (NULL == ref)
1094  	{
1095          CFErrorRef result = CreateSecTransformErrorRef(kSecTransformErrorInvalidInput,
1096  			"SecTransformSetAttributeNotificationAction called with a NULL SecTransformImplementationRef ref");
1097          CFAutorelease(result);
1098  		return result;
1099  	}
1100  	
1101  	return (CFErrorRef)ref->overrideTransform(action, newAction);
1102  }
1103  
1104  CFTypeRef SecTranformCustomGetAttribute(SecTransformImplementationRef ref,
1105                                          SecTransformStringOrAttributeRef attribute,
1106                                          SecTransformMetaAttributeType type)
1107  {
1108  	if (NULL == ref)
1109  	{
1110          CFErrorRef result = CreateSecTransformErrorRef(kSecTransformErrorInvalidInput, 
1111                                                         "SecTransformCustomGetAttribute called with a NULL SecTransformImplementationRef ref");
1112          CFAutorelease(result);
1113  		return result;
1114  	}
1115  	
1116  	return (CFErrorRef)ref->get(attribute, type);
1117  }
1118  
1119  CFTypeRef SecTransformCustomSetAttribute(SecTransformImplementationRef ref,
1120  									SecTransformStringOrAttributeRef attribute, 
1121  									SecTransformMetaAttributeType type, 
1122  									CFTypeRef value)
1123  {
1124  	if (NULL == ref)
1125  	{
1126          CFErrorRef result = CreateSecTransformErrorRef(kSecTransformErrorInvalidInput,
1127  			"SecTransformCustomSetAttribute called with a NULL SecTransformImplementationRef ref");
1128          CFAutorelease(result);
1129  		return result;
1130  	}
1131  	
1132  	return (CFErrorRef)ref->send(attribute, type, value);
1133  	
1134  }
1135  
1136  CFTypeRef SecTransformPushbackAttribute(SecTransformImplementationRef ref,
1137  								SecTransformStringOrAttributeRef attribute, 
1138  								CFTypeRef value)
1139  {
1140  	if (NULL == ref)
1141  	{
1142          CFErrorRef result = CreateSecTransformErrorRef(kSecTransformErrorInvalidInput,
1143  			"SecTransformPushbackAttribute called with a NULL SecTransformImplementationRef ref");
1144          CFAutorelease(result);
1145  		return (CFTypeRef)result;
1146  	}
1147  	
1148  	return ref->pushback(attribute, value);
1149  }