Logo Search packages:      
Sourcecode: chromium-browser version File versions  Download package

osxcode.h

/*
 * Copyright (c) 2000-2001 Apple Computer, Inc. All Rights Reserved.
 * 
 * The contents of this file constitute Original Code as defined in and are
 * subject to the Apple Public Source License Version 1.2 (the 'License').
 * You may not use this file except in compliance with the License. Please obtain
 * a copy of the License at http://www.apple.com/publicsource and read it before
 * using this file.
 * 
 * This Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS
 * OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, INCLUDING WITHOUT
 * LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 * PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. Please see the License for the
 * specific language governing rights and limitations under the License.
 */


//
// osxcode - MacOS X's standard code objects
//
#ifndef _H_OSXCODE
#define _H_OSXCODE

#include <security_utilities/codesigning.h>
#include <security_utilities/refcount.h>
#include <security_utilities/cfutilities.h>
#include <limits.h>
#include <string>
#include <vector>
#include <CoreFoundation/CFBundle.h>


namespace Security {


//
// A Signable with OS X support calls added
//
class OSXCode : public RefCount, public CodeSigning::Signable {
public:
      // encoding and decoding as a UTF-8 string
      virtual string encode() const = 0;
      static OSXCode *decode(const char *extForm);
      
public:
      // creating OSXCode objects
      static RefPointer<OSXCode> main();
      static RefPointer<OSXCode> at(const char *path);
      static RefPointer<OSXCode> at(const std::string &path)
      { return at(path.c_str()); }
      
      template <class Code>
      static RefPointer<Code> main() { return restrict<Code>(main()); }
      template <class Code>
      static RefPointer<Code> at(const char *path) { return restrict<Code>(at(path)); }
      template <class Code>
      static RefPointer<Code> at(const std::string &path)   { return restrict<Code>(at(path)); }

      // restrict (validate) to subclass or throw
      template <class Sub>
      static RefPointer<Sub> restrict(RefPointer<OSXCode> in)
      {
            if (Sub *sub = dynamic_cast<Sub *>(in.get()))
                  return sub;
            else
                  UnixError::throwMe(ENOEXEC);
      }
      
public:
      // produce the best approximation of a path that, when handed to at(),
      // will yield an OSXCode that's the most like this one
      virtual string canonicalPath() const = 0;
      virtual string executablePath() const = 0;

protected:
      OSXCode() { }     // nonpublic
      static void scanFile(const char *pathname, CodeSigning::Signer::State &state);      // scan an entire file
};


//
// A simple executable tool.
//
class ExecutableTool : public OSXCode {
public:
      ExecutableTool(const char *path) : mPath(path) { }
      string encode() const;
      
      string path() const           { return mPath; }
      string canonicalPath() const;
      string executablePath() const;
      
protected:
      void scanContents(CodeSigning::Signer::State &state) const;

private:
      string mPath;                 // UTF8 pathname to executable
};


//
// A generic bundle
//
class GenericBundle : public OSXCode {
public:
      GenericBundle(const char *path, const char *execPath = NULL);     // from root and optional exec path
      GenericBundle(CFBundleRef bundle, const char *root = NULL);       // from existing CFBundleRef
      ~GenericBundle();

      string encode() const;
      
      string canonicalPath() const;
      string path() const                       { return mPath; }
      string executablePath() const;
      string identifier() const           { return cfString(CFBundleGetIdentifier(cfBundle())); }
      CFTypeRef infoPlistItem(const char *name) const;      // not retained

      string resourcePath() const         { return cfString(CFBundleCopyResourcesDirectoryURL(cfBundle()), true); }
      string resource(const char *name, const char *type, const char *subdir = NULL);
      void resources(vector<string> &paths, const char *type, const char *subdir = NULL);
      
      virtual void *lookupSymbol(const char *name);

protected:
      void scanContents(CodeSigning::Signer::State &state) const;
      CFBundleRef cfBundle() const;
      
protected:
      string mPath;                 // UTF8 path to bundle directory
      mutable string mExecutablePath;     // cached or determined path to main executable
      mutable CFBundleRef mBundle; // CF-style bundle object (lazily built)
};

class ApplicationBundle : public GenericBundle {
public:
      ApplicationBundle(const char *pathname) : GenericBundle(pathname) { }
      ApplicationBundle(CFBundleRef bundle) : GenericBundle(bundle) { }
};

class LoadableBundle : public GenericBundle {
public:
      LoadableBundle(const char *pathname) : GenericBundle(pathname) { }
      LoadableBundle(CFBundleRef bundle) : GenericBundle(bundle) { }
      
      virtual bool isLoaded() const;
      virtual void load();
      virtual void unload();
};


} // end namespace Security


#endif //_H_OSXCODE

Generated by  Doxygen 1.6.0   Back to index