| //////////////////////////////////////////////////////////////////////////////// |
| // |
| // Licensed to the Apache Software Foundation (ASF) under one or more |
| // contributor license agreements. See the NOTICE file distributed with |
| // this work for additional information regarding copyright ownership. |
| // The ASF licenses this file to You under the Apache License, Version 2.0 |
| // (the "License"); you may not use this file except in compliance with |
| // the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| // |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| package mx.core |
| { |
| |
| import flash.display.Loader; |
| import flash.events.Event; |
| import flash.events.ErrorEvent; |
| import flash.events.ProgressEvent; |
| import flash.events.IOErrorEvent; |
| import flash.events.SecurityErrorEvent; |
| import flash.net.URLRequest; |
| import flash.net.URLLoader; |
| import flash.net.URLLoaderDataFormat; |
| import flash.system.LoaderContext; |
| import flash.system.ApplicationDomain; |
| import flash.system.LoaderContext; |
| import flash.system.Security; |
| import flash.system.SecurityDomain; |
| import flash.utils.ByteArray; |
| //import flash.utils.getTimer; // PERFORMANCE_INFO |
| |
| import mx.core.RSLData; |
| import mx.events.RSLEvent; |
| import mx.utils.SHA256; |
| import mx.utils.LoaderUtil; |
| |
| [ExcludeClass] |
| |
| /** |
| * @private |
| * Cross-domain RSL Item Class. |
| * |
| * The rsls are typically located on a different host than the loader. |
| * There are signed and unsigned Rsls, both have a digest to confirm the |
| * correct rsl is loaded. |
| * Signed Rsls are loaded by setting the digest of the URLRequest. |
| * Unsigned Rsls are check using actionScript to calculate a sha-256 hash of |
| * the loaded bytes and compare them to the expected digest. |
| * |
| */ |
| public class CrossDomainRSLItem extends RSLItem |
| { |
| include "../core/Version.as"; |
| |
| //-------------------------------------------------------------------------- |
| // |
| // Variables |
| // |
| //-------------------------------------------------------------------------- |
| |
| private var rsls:Array = []; // of type RSLInstanceData |
| // private var rslUrls:Array; // first url is the primary url in the url parameter, others are failovers |
| // private var policyFileUrls:Array; // optional policy files, parallel array to rslUrls |
| // private var digests:Array; // option rsl digest, parallel array to rslUrls |
| // private var isSigned:Array; // each entry is a boolean value. "true" if the rsl in the parallel array is signed |
| // private var hashTypes:Array; // type of hash used to create the digest |
| private var urlIndex:int = 0; // index into url being loaded in rslsUrls and other parallel arrays |
| |
| // this reference to the loader keeps the loader from being garbage |
| // collected before the complete event can be sent. |
| private var loadBytesLoader:Loader; |
| |
| // private var startTime:int; // PERFORMANCE_INFO |
| |
| //-------------------------------------------------------------------------- |
| // |
| // Constructor |
| // |
| //-------------------------------------------------------------------------- |
| |
| /** |
| * Create a cross-domain RSL item to load. |
| * |
| * @param rsls Array of Objects. Each Object describes and RSL to load. |
| * The first Object in the Array is the primary RSL and the others are |
| * failover RSLs. |
| * @param rootURL provides the url used to locate relative RSL urls. |
| * @param moduleFactory The module factory that is loading the RSLs. The |
| * RSLs will be loaded into the application domain of the given module factory. |
| * If a module factory is not specified, then the RSLs will be loaded into the |
| * application domain of where the CrossDomainRSLItem class was first loaded. |
| * |
| * @langversion 3.0 |
| * @playerversion Flash 9 |
| * @playerversion AIR 1.1 |
| * @productversion Flex 3 |
| */ |
| public function CrossDomainRSLItem(rsls:Array, |
| rootURL:String = null, |
| moduleFactory:IFlexModuleFactory = null) |
| { |
| super(rsls[0].rslURL, rootURL, moduleFactory); |
| |
| this.rsls = rsls; |
| |
| // startTime = getTimer(); // PERFORMANCE_INFO |
| } |
| |
| |
| //-------------------------------------------------------------------------- |
| // |
| // Properties |
| // |
| //-------------------------------------------------------------------------- |
| |
| |
| /** |
| * Get the RSLData for the current RSL. This could be the primary RSL or one |
| * of the failover RSLs. |
| * |
| * @langversion 3.0 |
| * @playerversion Flash 9 |
| * @playerversion AIR 1.1 |
| * @productversion Flex 3 |
| */ |
| private function get currentRSLData():RSLData |
| { |
| return RSLData(rsls[urlIndex]); |
| } |
| |
| //-------------------------------------------------------------------------- |
| // |
| // Overridden Methods |
| // |
| //-------------------------------------------------------------------------- |
| |
| |
| /** |
| * |
| * Load an RSL. |
| * |
| * @param progressHandler receives ProgressEvent.PROGRESS events, may be null |
| * @param completeHandler receives Event.COMPLETE events, may be null |
| * @param ioErrorHandler receives IOErrorEvent.IO_ERROR events, may be null |
| * @param securityErrorHandler receives SecurityErrorEvent.SECURITY_ERROR events, may be null |
| * @param rslErrorHandler receives RSLEvent.RSL_ERROR events, may be null |
| * |
| * |
| * @langversion 3.0 |
| * @playerversion Flash 9 |
| * @playerversion AIR 1.1 |
| * @productversion Flex 3 |
| */ |
| override public function load(progressHandler:Function, |
| completeHandler:Function, |
| ioErrorHandler:Function, |
| securityErrorHandler:Function, |
| rslErrorHandler:Function):void |
| { |
| chainedProgressHandler = progressHandler; |
| chainedCompleteHandler = completeHandler; |
| chainedIOErrorHandler = ioErrorHandler; |
| chainedSecurityErrorHandler = securityErrorHandler; |
| chainedRSLErrorHandler = rslErrorHandler; |
| |
| |
| /* |
| // Debug loading of swf files |
| |
| trace("begin load of " + url); |
| if (Security.sandboxType == Security.REMOTE) |
| { |
| trace(" in REMOTE sandbox"); |
| } |
| else if (Security.sandboxType == Security.LOCAL_TRUSTED) |
| { |
| trace(" in LOCAL_TRUSTED sandbox"); |
| } |
| else if (Security.sandboxType == Security.LOCAL_WITH_FILE) |
| { |
| trace(" in LOCAL_WITH_FILE sandbox"); |
| } |
| else if (Security.sandboxType == Security.LOCAL_WITH_NETWORK) |
| { |
| trace(" in LOCAL_WITH_NETWORK sandbox"); |
| } |
| * |
| * @langversion 3.0 |
| * @playerversion Flash 9 |
| * @playerversion AIR 1.1 |
| * @productversion Flex 3 |
| */ |
| |
| var rslData:RSLData = currentRSLData; |
| urlRequest = new URLRequest(LoaderUtil.createAbsoluteURL(rootURL, rslData.rslURL)); |
| |
| var loader:URLLoader = new URLLoader(); |
| loader.dataFormat = URLLoaderDataFormat.BINARY; |
| |
| // We needs to listen to certain events. |
| |
| loader.addEventListener( |
| ProgressEvent.PROGRESS, itemProgressHandler); |
| |
| loader.addEventListener( |
| Event.COMPLETE, itemCompleteHandler); |
| |
| loader.addEventListener( |
| IOErrorEvent.IO_ERROR, itemErrorHandler); |
| |
| loader.addEventListener( |
| SecurityErrorEvent.SECURITY_ERROR, itemErrorHandler); |
| |
| if (rslData.policyFileURL != "") |
| { |
| Security.loadPolicyFile(rslData.policyFileURL); |
| } |
| |
| if (rslData.isSigned) |
| { |
| // load a signed rsl by specifying the digest |
| urlRequest.digest = rslData.digest; |
| } |
| |
| // trace("start load of " + urlRequest.url + " at " + (getTimer() - startTime)); // PERFORMANCE_INFO |
| |
| loader.load(urlRequest); |
| } |
| |
| |
| |
| //-------------------------------------------------------------------------- |
| // |
| // Methods |
| // |
| //-------------------------------------------------------------------------- |
| |
| /** |
| * @private |
| * Complete the load of the cross-domain rsl by loading it into the current |
| * application domain. The load was started by loadCdRSL. |
| * |
| * @param - urlLoader from the complete event. |
| * |
| * @return - true if the load was completed successfully or unsuccessfully, |
| * false if the load of a failover rsl was started |
| */ |
| private function completeCdRslLoad(urlLoader:URLLoader):Boolean |
| { |
| // handle player bug #204244, complete event without data after an error |
| if (urlLoader == null || urlLoader.data == null || ByteArray(urlLoader.data).bytesAvailable == 0) |
| { |
| return true; |
| } |
| |
| // load the bytes into the current application domain. |
| loadBytesLoader = new Loader(); |
| var context:LoaderContext = new LoaderContext(); |
| var rslData:RSLData = currentRSLData; |
| |
| if (rslData.moduleFactory) |
| { |
| context.applicationDomain = rslData.moduleFactory.info()["currentDomain"]; |
| } |
| else if (moduleFactory) |
| { |
| context.applicationDomain = moduleFactory.info()["currentDomain"]; |
| } |
| else |
| { |
| context.applicationDomain = ApplicationDomain.currentDomain; |
| } |
| |
| context.securityDomain = null; |
| |
| // Set the allowCodeImport flag so we can load the RSL without a security error. |
| context.allowCodeImport = true; |
| |
| // verify the digest, if any, is correct |
| if (rslData.digest != null && rslData.verifyDigest) |
| { |
| var verifiedDigest:Boolean = false; |
| if (!rslData.isSigned) |
| { |
| // verify an unsigned rsl |
| if (rslData.hashType == SHA256.TYPE_ID) |
| { |
| // get the bytes from the rsl and calculate the hash |
| var rslDigest:String = null; |
| if (urlLoader.data != null) |
| { |
| rslDigest = SHA256.computeDigest(urlLoader.data); |
| } |
| |
| if (rslDigest == rslData.digest) |
| { |
| verifiedDigest = true; |
| } |
| } |
| } |
| else |
| { |
| // signed rsls are verified by the player |
| verifiedDigest = true; |
| } |
| |
| if (!verifiedDigest) |
| { |
| // failover to the next rsl, if one exists |
| // no failover to load, all the rsls have failed to load |
| // report an error. |
| // B Feature: externalize error message |
| var hasFailover:Boolean = this.hasFailover(); |
| var rslError:ErrorEvent = new ErrorEvent(RSLEvent.RSL_ERROR); |
| rslError.text = "Flex Error #1001: Digest mismatch with RSL " + |
| urlRequest.url + |
| ". Redeploy the matching RSL or relink your application with the matching library."; |
| itemErrorHandler(rslError); |
| |
| return !hasFailover; |
| } |
| } |
| |
| // load the rsl into memory |
| loadBytesLoader.contentLoaderInfo.addEventListener(Event.COMPLETE, loadBytesCompleteHandler); |
| loadBytesLoader.loadBytes(urlLoader.data, context); |
| return true; |
| } |
| |
| |
| /** |
| * Does the current url being processed have a failover? |
| * |
| * @return true if a failover url exists, false otherwise. |
| * |
| * @langversion 3.0 |
| * @playerversion Flash 9 |
| * @playerversion AIR 1.1 |
| * @productversion Flex 3 |
| */ |
| public function hasFailover():Boolean |
| { |
| return (rsls.length > (urlIndex + 1)); |
| } |
| |
| |
| /** |
| * Load the next url from the list of failover urls. |
| * |
| * @langversion 3.0 |
| * @playerversion Flash 9 |
| * @playerversion AIR 1.1 |
| * @productversion Flex 3 |
| */ |
| public function loadFailover():void |
| { |
| // try to load the failover from the same node again |
| if (urlIndex < rsls.length) |
| { |
| trace("Failed to load RSL " + currentRSLData.rslURL); |
| trace("Failing over to RSL " + RSLData(rsls[urlIndex+1]).rslURL); |
| urlIndex++; // move to failover url |
| url = currentRSLData.rslURL; |
| load(chainedProgressHandler, |
| chainedCompleteHandler, |
| chainedIOErrorHandler, |
| chainedSecurityErrorHandler, |
| chainedRSLErrorHandler); |
| } |
| } |
| |
| //-------------------------------------------------------------------------- |
| // |
| // Overridden Event Handlers |
| // |
| //-------------------------------------------------------------------------- |
| |
| /** |
| * @private |
| */ |
| override public function itemCompleteHandler(event:Event):void |
| { |
| // trace("complete load of " + url + " at " + (getTimer() - startTime)); // PERFORMANCE_INFO |
| |
| // complete loading the cross-domain rsl by calling loadBytes. |
| completeCdRslLoad(event.target as URLLoader); |
| } |
| |
| /** |
| * @private |
| */ |
| override public function itemErrorHandler(event:ErrorEvent):void |
| { |
| // trace("error loading " + url + " at " + (getTimer() - startTime)); // PERFORMANCE_INFO |
| |
| // if a failover exists, try to load it. Otherwise call super() |
| // for default error handling. |
| if (hasFailover()) |
| { |
| trace(decodeURI(event.text)); |
| loadFailover(); |
| } |
| else |
| { |
| super.itemErrorHandler(event); |
| } |
| } |
| |
| |
| /** |
| * loader.loadBytes() has a complete event. |
| * Done loading this rsl into memory. Call the completeHandler |
| * to start loading the next rsl. |
| * |
| * @private |
| */ |
| private function loadBytesCompleteHandler(event:Event):void |
| { |
| loadBytesLoader.contentLoaderInfo.removeEventListener(Event.COMPLETE, loadBytesCompleteHandler); |
| loadBytesLoader = null; |
| super.itemCompleteHandler(event); |
| } |
| |
| } |
| } |
