--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/WebKit/mac/Plugins/WebBasePluginPackage.mm Fri Sep 17 09:02:29 2010 +0300
@@ -0,0 +1,471 @@
+/*
+ * Copyright (C) 2005 Apple Computer, Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of
+ * its contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#import <WebKit/WebBasePluginPackage.h>
+
+#import <algorithm>
+#import <WebCore/WebCoreObjCExtras.h>
+#import <WebKit/WebKitNSStringExtras.h>
+#import <WebKit/WebNSObjectExtras.h>
+#import <WebKit/WebNetscapePluginPackage.h>
+#import <WebKit/WebPluginPackage.h>
+#import <runtime/InitializeThreading.h>
+#import <wtf/Assertions.h>
+#import <wtf/Threading.h>
+#import <wtf/Vector.h>
+
+#import <WebKitSystemInterface.h>
+
+#import "WebKitLogging.h"
+#import "WebTypesInternal.h"
+
+#import <mach-o/arch.h>
+#import <mach-o/fat.h>
+#import <mach-o/loader.h>
+
+#define JavaCocoaPluginIdentifier "com.apple.JavaPluginCocoa"
+#define JavaCarbonPluginIdentifier "com.apple.JavaAppletPlugin"
+#define JavaCFMPluginFilename "Java Applet Plugin Enabler"
+
+#define QuickTimeCarbonPluginIdentifier "com.apple.QuickTime Plugin.plugin"
+#define QuickTimeCocoaPluginIdentifier "com.apple.quicktime.webplugin"
+
+@interface NSArray (WebPluginExtensions)
+- (NSArray *)_web_lowercaseStrings;
+@end;
+
+using namespace std;
+using namespace WebCore;
+
+@implementation WebBasePluginPackage
+
++ (void)initialize
+{
+ JSC::initializeThreading();
+ WTF::initializeMainThreadToProcessMainThread();
+#ifndef BUILDING_ON_TIGER
+ WebCoreObjCFinalizeOnMainThread(self);
+#endif
+}
+
++ (WebBasePluginPackage *)pluginWithPath:(NSString *)pluginPath
+{
+
+ WebBasePluginPackage *pluginPackage = [[WebPluginPackage alloc] initWithPath:pluginPath];
+
+ if (!pluginPackage) {
+#if ENABLE(NETSCAPE_PLUGIN_API)
+ pluginPackage = [[WebNetscapePluginPackage alloc] initWithPath:pluginPath];
+#else
+ return nil;
+#endif
+ }
+
+ return [pluginPackage autorelease];
+}
+
++ (NSString *)preferredLocalizationName
+{
+ return WebCFAutorelease(WKCopyCFLocalizationPreferredName(NULL));
+}
+
+static NSString *pathByResolvingSymlinksAndAliases(NSString *thePath)
+{
+ NSString *newPath = [thePath stringByResolvingSymlinksInPath];
+
+ FSRef fref;
+ OSStatus err;
+
+ err = FSPathMakeRef((const UInt8 *)[thePath fileSystemRepresentation], &fref, NULL);
+ if (err != noErr)
+ return newPath;
+
+ Boolean targetIsFolder;
+ Boolean wasAliased;
+ err = FSResolveAliasFileWithMountFlags(&fref, TRUE, &targetIsFolder, &wasAliased, kResolveAliasFileNoUI);
+ if (err != noErr)
+ return newPath;
+
+ if (wasAliased) {
+ CFURLRef URL = CFURLCreateFromFSRef(kCFAllocatorDefault, &fref);
+ newPath = [(NSURL *)URL path];
+ CFRelease(URL);
+ }
+
+ return newPath;
+}
+
+- (id)initWithPath:(NSString *)pluginPath
+{
+ if (!(self = [super init]))
+ return nil;
+
+ path = pathByResolvingSymlinksAndAliases(pluginPath);
+ cfBundle.adoptCF(CFBundleCreate(kCFAllocatorDefault, (CFURLRef)[NSURL fileURLWithPath:path]));
+
+#ifndef __ppc__
+ // 32-bit PowerPC is the only platform where non-bundled CFM plugins are supported
+ if (!cfBundle) {
+ [self release];
+ return nil;
+ }
+#endif
+
+ return self;
+}
+
+- (void)unload
+{
+}
+
+- (void)createPropertyListFile
+{
+ if ([self load] && BP_CreatePluginMIMETypesPreferences) {
+ BP_CreatePluginMIMETypesPreferences();
+ [self unload];
+ }
+}
+
+- (NSDictionary *)pListForPath:(NSString *)pListPath createFile:(BOOL)createFile
+{
+ if (createFile)
+ [self createPropertyListFile];
+
+ NSDictionary *pList = nil;
+ NSData *data = [NSData dataWithContentsOfFile:pListPath];
+ if (data) {
+ pList = [NSPropertyListSerialization propertyListFromData:data
+ mutabilityOption:NSPropertyListImmutable
+ format:nil
+ errorDescription:nil];
+ }
+
+ return pList;
+}
+
+- (id)_objectForInfoDictionaryKey:(NSString *)key
+{
+ CFDictionaryRef bundleInfoDictionary = CFBundleGetInfoDictionary(cfBundle.get());
+ if (!bundleInfoDictionary)
+ return nil;
+
+ return (id)CFDictionaryGetValue(bundleInfoDictionary, key);
+}
+
+- (BOOL)getPluginInfoFromPLists
+{
+ if (!cfBundle)
+ return NO;
+
+ NSDictionary *MIMETypes = nil;
+ NSString *pListFilename = [self _objectForInfoDictionaryKey:WebPluginMIMETypesFilenameKey];
+
+ // Check if the MIME types are claimed in a plist in the user's preferences directory.
+ if (pListFilename) {
+ NSString *pListPath = [NSString stringWithFormat:@"%@/Library/Preferences/%@", NSHomeDirectory(), pListFilename];
+ NSDictionary *pList = [self pListForPath:pListPath createFile:NO];
+ if (pList) {
+ // If the plist isn't localized, have the plug-in recreate it in the preferred language.
+ NSString *localizationName = [pList objectForKey:WebPluginLocalizationNameKey];
+ if (![localizationName isEqualToString:[[self class] preferredLocalizationName]])
+ pList = [self pListForPath:pListPath createFile:YES];
+ MIMETypes = [pList objectForKey:WebPluginMIMETypesKey];
+ } else
+ // Plist doesn't exist, ask the plug-in to create it.
+ MIMETypes = [[self pListForPath:pListPath createFile:YES] objectForKey:WebPluginMIMETypesKey];
+ }
+
+ if (!MIMETypes) {
+ MIMETypes = [self _objectForInfoDictionaryKey:WebPluginMIMETypesKey];
+ if (!MIMETypes)
+ return NO;
+ }
+
+ NSEnumerator *keyEnumerator = [MIMETypes keyEnumerator];
+ NSDictionary *MIMEDictionary;
+ NSString *MIME, *description;
+ NSArray *extensions;
+
+ while ((MIME = [keyEnumerator nextObject]) != nil) {
+ MIMEDictionary = [MIMETypes objectForKey:MIME];
+
+ // FIXME: Consider storing disabled MIME types.
+ NSNumber *isEnabled = [MIMEDictionary objectForKey:WebPluginTypeEnabledKey];
+ if (isEnabled && [isEnabled boolValue] == NO)
+ continue;
+
+ MimeClassInfo mimeClassInfo;
+
+ extensions = [[MIMEDictionary objectForKey:WebPluginExtensionsKey] _web_lowercaseStrings];
+ for (NSUInteger i = 0; i < [extensions count]; ++i)
+ mimeClassInfo.extensions.append((NSString *)[extensions objectAtIndex:i]);
+
+ if ([extensions count] == 0)
+ extensions = [NSArray arrayWithObject:@""];
+
+ mimeClassInfo.type = String(MIME).lower();
+
+ description = [MIMEDictionary objectForKey:WebPluginTypeDescriptionKey];
+ mimeClassInfo.desc = description;
+
+ pluginInfo.mimes.append(mimeClassInfo);
+ if (!description)
+ description = @"";
+ }
+
+ NSString *filename = [(NSString *)path lastPathComponent];
+ pluginInfo.file = filename;
+
+ NSString *theName = [self _objectForInfoDictionaryKey:WebPluginNameKey];
+ if (!theName)
+ theName = filename;
+ pluginInfo.name = theName;
+
+ description = [self _objectForInfoDictionaryKey:WebPluginDescriptionKey];
+ if (!description)
+ description = filename;
+ pluginInfo.desc = description;
+
+ return YES;
+}
+
+- (BOOL)load
+{
+ if (cfBundle && !BP_CreatePluginMIMETypesPreferences)
+ BP_CreatePluginMIMETypesPreferences = (BP_CreatePluginMIMETypesPreferencesFuncPtr)CFBundleGetFunctionPointerForName(cfBundle.get(), CFSTR("BP_CreatePluginMIMETypesPreferences"));
+
+ return YES;
+}
+
+- (void)dealloc
+{
+ ASSERT(!pluginDatabases || [pluginDatabases count] == 0);
+ [pluginDatabases release];
+
+ [super dealloc];
+}
+
+- (void)finalize
+{
+ ASSERT_MAIN_THREAD();
+ ASSERT(!pluginDatabases || [pluginDatabases count] == 0);
+ [pluginDatabases release];
+
+ [super finalize];
+}
+
+- (const String&)path
+{
+ return path;
+}
+
+- (const PluginInfo&)pluginInfo
+{
+ return pluginInfo;
+}
+
+- (BOOL)supportsExtension:(const String&)extension
+{
+ ASSERT(extension.lower() == extension);
+
+ for (size_t i = 0; i < pluginInfo.mimes.size(); ++i) {
+ const Vector<String>& extensions = pluginInfo.mimes[i].extensions;
+
+ if (find(extensions.begin(), extensions.end(), extension) != extensions.end())
+ return YES;
+ }
+
+ return NO;
+}
+
+- (BOOL)supportsMIMEType:(const WebCore::String&)mimeType
+{
+ ASSERT(mimeType.lower() == mimeType);
+
+ for (size_t i = 0; i < pluginInfo.mimes.size(); ++i) {
+ if (pluginInfo.mimes[i].type == mimeType)
+ return YES;
+ }
+
+ return NO;
+}
+
+- (NSString *)MIMETypeForExtension:(const String&)extension
+{
+ ASSERT(extension.lower() == extension);
+
+ for (size_t i = 0; i < pluginInfo.mimes.size(); ++i) {
+ const MimeClassInfo& mimeClassInfo = pluginInfo.mimes[i];
+ const Vector<String>& extensions = mimeClassInfo.extensions;
+
+ if (find(extensions.begin(), extensions.end(), extension) != extensions.end())
+ return mimeClassInfo.type;
+ }
+
+ return nil;
+}
+
+- (BOOL)isQuickTimePlugIn
+{
+ const String& bundleIdentifier = [self bundleIdentifier];
+ return bundleIdentifier == QuickTimeCocoaPluginIdentifier || bundleIdentifier == QuickTimeCocoaPluginIdentifier;
+}
+
+- (BOOL)isJavaPlugIn
+{
+ const String& bundleIdentifier = [self bundleIdentifier];
+ return bundleIdentifier == JavaCocoaPluginIdentifier || bundleIdentifier == JavaCarbonPluginIdentifier ||
+ equalIgnoringCase(pluginInfo.file, JavaCFMPluginFilename);
+}
+
+static inline void swapIntsInHeader(uint8_t* bytes, unsigned length)
+{
+ for (unsigned i = 0; i < length; i += 4)
+ *(uint32_t*)(bytes + i) = OSSwapInt32(*(uint32_t *)(bytes + i));
+}
+
+- (BOOL)isNativeLibraryData:(NSData *)data
+{
+ Vector<uint8_t, 512> bytes([data length]);
+ memcpy(bytes.data(), [data bytes], bytes.size());
+
+ unsigned numArchs = 0;
+ struct fat_arch singleArch = { 0, 0, 0, 0, 0 };
+ struct fat_arch* archs = 0;
+
+ if (bytes.size() >= sizeof(struct mach_header_64)) {
+ uint32_t magic = *reinterpret_cast<uint32_t*>(bytes.data());
+
+ if (magic == MH_MAGIC || magic == MH_CIGAM) {
+ // We have a 32-bit thin binary
+ struct mach_header* header = (struct mach_header*)bytes.data();
+
+ // Check if we need to swap the bytes
+ if (magic == MH_CIGAM)
+ swapIntsInHeader(bytes.data(), bytes.size());
+
+ singleArch.cputype = header->cputype;
+ singleArch.cpusubtype = header->cpusubtype;
+
+ archs = &singleArch;
+ numArchs = 1;
+ } else if (magic == MH_MAGIC_64 || magic == MH_CIGAM_64) {
+ // We have a 64-bit thin binary
+ struct mach_header_64* header = (struct mach_header_64*)bytes.data();
+
+ // Check if we need to swap the bytes
+ if (magic == MH_CIGAM_64)
+ swapIntsInHeader(bytes.data(), bytes.size());
+
+ singleArch.cputype = header->cputype;
+ singleArch.cpusubtype = header->cpusubtype;
+
+ archs = &singleArch;
+ numArchs = 1;
+ } else if (magic == FAT_MAGIC || magic == FAT_CIGAM) {
+ // We have a fat (universal) binary
+
+ // Check if we need to swap the bytes
+ if (magic == FAT_CIGAM)
+ swapIntsInHeader(bytes.data(), bytes.size());
+
+ archs = (struct fat_arch*)(bytes.data() + sizeof(struct fat_header));
+ numArchs = ((struct fat_header *)bytes.data())->nfat_arch;
+
+ unsigned maxArchs = (bytes.size() - sizeof(struct fat_header)) / sizeof(struct fat_arch);
+ if (numArchs > maxArchs)
+ numArchs = maxArchs;
+ }
+ }
+
+ if (!archs || !numArchs)
+ return NO;
+
+ const NXArchInfo* localArch = NXGetLocalArchInfo();
+ if (!localArch)
+ return NO;
+
+ cpu_type_t cputype = localArch->cputype;
+ cpu_subtype_t cpusubtype = localArch->cpusubtype;
+
+#ifdef __x86_64__
+ // NXGetLocalArchInfo returns CPU_TYPE_X86 even when running in 64-bit.
+ // See <rdar://problem/4996965> for more information.
+ cputype = CPU_TYPE_X86_64;
+#endif
+
+ return NXFindBestFatArch(cputype, cpusubtype, archs, numArchs) != 0;
+}
+
+- (UInt32)versionNumber
+{
+ // CFBundleGetVersionNumber doesn't work with all possible versioning schemes, but we think for now it's good enough for us.
+ return CFBundleGetVersionNumber(cfBundle.get());
+}
+
+- (void)wasAddedToPluginDatabase:(WebPluginDatabase *)database
+{
+ if (!pluginDatabases)
+ pluginDatabases = [[NSMutableSet alloc] init];
+
+ ASSERT(![pluginDatabases containsObject:database]);
+ [pluginDatabases addObject:database];
+}
+
+- (void)wasRemovedFromPluginDatabase:(WebPluginDatabase *)database
+{
+ ASSERT(pluginDatabases);
+ ASSERT([pluginDatabases containsObject:database]);
+
+ [pluginDatabases removeObject:database];
+}
+
+- (WebCore::String)bundleIdentifier
+{
+ return CFBundleGetIdentifier(cfBundle.get());
+}
+
+@end
+
+@implementation NSArray (WebPluginExtensions)
+
+- (NSArray *)_web_lowercaseStrings
+{
+ NSMutableArray *lowercaseStrings = [NSMutableArray arrayWithCapacity:[self count]];
+ NSEnumerator *strings = [self objectEnumerator];
+ NSString *string;
+
+ while ((string = [strings nextObject]) != nil) {
+ if ([string isKindOfClass:[NSString class]])
+ [lowercaseStrings addObject:[string lowercaseString]];
+ }
+
+ return lowercaseStrings;
+}
+
+@end