source: trunk/Cocoa/F-Script Anywhere/Source/SCPatch/SCPatchController/SCPatchController.h @ 231

#pragma once
#include <Carbon/Carbon.h>
#include <list>

using namespace std;

#include "SCPatchPrivate.h"
#include "SCPatchContext.h"
#include "SCPatchRecord.h"
#include "SCPatchMessenger.h"

//      Mac to Mach error morphing.
#define err_mac                 err_system(0xf) /* Mac (Carbon) errors */
#define mac_err(CODE)   SCmac_err_FromOSErr((CODE))
#define oserr(CODE)             SCOSErrFrom_mac_err((CODE))
mach_error_t SCmac_err_FromOSErr(OSErr err);
OSErr SCOSErrFrom_mac_err(mach_error_t error);

typedef OSErr   (*SCPatchIterationProc)(ProcessSerialNumber *inPSN, OSType inCreator, UInt32 inFlags, void *data);

class SCPatchController : public SCPatchMessenger
{
  public:
  
        SCPatchController(void);
        SCPatchController(CFStringRef bundleIdentifier);
        ~SCPatchController(void);
        
        // Use these to tell the controller where to find the patches
        void                                    AddPatch(CFStringRef patchBundleIdentifier,
                                                                         CFStringRef subPath,
                                                                         CFStringRef name);
                                                                                           
        // Inject the patches into running applications and start watching app launches   
        OSErr                                   InstallPatches(void);
        
        // Patch a single process (ignoring return value of ShouldPatchProcess)
        mach_error_t                    PatchProcess(ProcessSerialNumber *psn);
        
        // Overload these to customize patch loading and notification (note that 
        // UnpatchNotification is only called when the process dies, since the patches
        // are not removable).
        virtual Boolean                 ShouldPatchProcess(ProcessSerialNumber * /* inPSN */,
                                                                        OSType /* inCreator */, OSType /* type */,
                                                                        CFStringRef /* name */, UInt32 /* flags */) { return false; }
        virtual void                    PatchNotification(ProcessSerialNumber * /* inPSN */,
                                                                        OSType /* inCreator */, OSType /* type */,
                                                                        CFStringRef /* name */, UInt32 /* flags */) {}
        virtual void                    UnpatchNotification(ProcessSerialNumber * /* inPSN */,
                                                                        OSType /* inCreator */, OSType /* type */,
                                                                        CFStringRef /* name */, UInt32 /* flags */) {}
                
    // You must also overload this method in SCPatchMessenger to receive messages.
        // virtual void         ReceiveMessage(const AppleEvent *theAE) = 0;

        // Get info and keep tabs on patched processes
        Boolean                                 IsProcessPatched(ProcessSerialNumber *inPSN);
        UInt32                                  GetPatchFlags(ProcessSerialNumber *inPSN);
        void                                    SetPatchFlags(ProcessSerialNumber *inPSN, UInt32 flags, UInt32 whichFlags);
        
        // Loop through each patched process and execute a function.  Note that this will 
        // not recognize patched processes until after you've called IsProcessPatched() on  
        // them or called InstallPatches() (which calls IsProcessPatched on every process).
        OSErr                                   ForEachPatchedProcess(SCPatchIterationProc proc, void *data);

  private:
        CFBundleRef                             mBundle;
        CFStringRef                             mApplicationBundleIdentifier;
        
  private:
        list<SCPatchRecord>             mPatchList;
        SCPatchContextList              mPatchContextList;

        
        OSErr                                   HandleMessage(const AppleEvent *theAE);
        static pascal OSStatus  ApplicationEventHandler(EventHandlerCallRef handlerRef, 
                                                                                                        EventRef event, void *userData);
                                                
        mach_error_t                    InstallPatchesInProcess(ProcessSerialNumber *psn, bool onDemand=false);
        OSErr                                   AddPatchToParams(CFStringRef bundleID, CFURLRef url, SCPatchLoaderParams **params);
        mach_error_t                    InjectPatches(ProcessSerialNumber *psn, SCPatchLoaderParams *params);
        OSErr                                   RecordPatchAndNotify(ProcessSerialNumber *psn, ProcessInfoRec *info);

};