aboutsummaryrefslogtreecommitdiff
path: root/includes/js/dojox/io/proxy
diff options
context:
space:
mode:
Diffstat (limited to 'includes/js/dojox/io/proxy')
-rw-r--r--includes/js/dojox/io/proxy/README82
-rw-r--r--includes/js/dojox/io/proxy/tests/frag.xml4
-rw-r--r--includes/js/dojox/io/proxy/tests/xip.html62
-rw-r--r--includes/js/dojox/io/proxy/xip.js441
-rw-r--r--includes/js/dojox/io/proxy/xip_client.html102
-rw-r--r--includes/js/dojox/io/proxy/xip_server.html382
6 files changed, 1073 insertions, 0 deletions
diff --git a/includes/js/dojox/io/proxy/README b/includes/js/dojox/io/proxy/README
new file mode 100644
index 0000000..8898a56
--- /dev/null
+++ b/includes/js/dojox/io/proxy/README
@@ -0,0 +1,82 @@
+-------------------------------------------------------------------------------
+Project Name
+-------------------------------------------------------------------------------
+Version 0.6
+Release date: 01/31/2008
+-------------------------------------------------------------------------------
+Project state:
+experimental
+-------------------------------------------------------------------------------
+Credits
+ James Burke (jburke@dojotoolkit.org)
+-------------------------------------------------------------------------------
+Project description
+
+The XHR IFrame Proxy (xip) allows you to do cross-domain XMLHttpRequests (XHRs).
+It works by using two iframes, one your domain (xip_client.html), one on the
+other domain (xip_server.html). They use fragment IDs in the iframe URLs to pass
+messages to each other. The xip.js file defines dojox.io.proxy.xip. This module
+intercepts XHR calls made by the Dojo XHR methods (dojo.xhr* methods). The module
+returns a facade object that acts like an XHR object. Once send is called on the
+facade, the facade's data is serialized, given to xip_client.html. xip_client.html
+then passes the serialized data to xip_server.html by changing xip_server.html's
+URL fragment ID (the #xxxx part of an URL). xip_server.html deserializes the
+message fragments, and does an XHR call, gets the response, and serializes the
+data. The serialized data is then passed back to xip_client.html by changing
+xip_client.html's fragment ID. Then the response is deserialized and used as
+the response inside the facade XHR object that was created by dojox.io.proxy.xip.
+-------------------------------------------------------------------------------
+Dependencies:
+
+xip.js: Dojo Core, dojox.data.dom
+xip_client.html: none
+xip_server.html: none (but see Additional Notes section)
+-------------------------------------------------------------------------------
+Documentation
+
+There is some documentation that applies to the Dojo 0.4.x version of these files:
+http://dojotoolkit.org/book/dojo-book-0-4/part-5-connecting-pieces/i-o/cross-domain-xmlhttprequest-using-iframe-proxy
+
+The general theory still applies to this code, but the specifics are different
+for the Dojo 0.9+ codebase. Doc updates hopefully after the basic code is ported.
+
+The current implementation destroys the iframes used for a request after the request
+completes. This seems to cause a memory leak, particularly in IE. So, it is not
+suited for doing polling cross-domain requests.
+-------------------------------------------------------------------------------
+Installation instructions
+
+Grab the following from the Dojox SVN Repository:
+http://svn.dojotoolkit.org/var/src/dojo/dojox/trunk/io/proxy/xip.js
+http://svn.dojotoolkit.org/var/src/dojo/dojox/trunk/io/proxy/xip_client.html
+
+Install into the following directory structure:
+/dojox/io/proxy/
+
+...which should be at the same level as your Dojo checkout.
+
+Grab the following from the Dojox SVN Repository:
+http://svn.dojotoolkit.org/var/src/dojo/dojox/trunk/io/proxy/xip_server.html
+
+and install it on the domain that you want to allow receiving cross-domain
+requests. Be sure to read the documentation, the Additional Notes below, and
+the in-file comments.
+-------------------------------------------------------------------------------
+Additional Notes
+
+xip_client.html and xip_server.html do not work right away. You need to uncomment
+out the script tags in the files. Additionally, xip_server.html requires a JS file,
+isAllowed.js, to be defined. See the notes in xip_server.html for more informaiton.
+
+XDOMAIN BUILD INSTRUCTIONS:
+The dojox.io.proxy module requires some setup to use with an xdomain build.
+The xip_client.html file has to be served from the same domain as your web page.
+It cannot be served from the domain that has the xdomain build. Download xip_client.html
+and install it on your server. Then set djConfig.xipClientUrl to the local path
+of xip_client.html (just use a path, not a whole URL, since it will be on the same
+domain as the page). The path to the file should be the path relative to the web
+page that is using dojox.io.proxy.
+
+
+
+
diff --git a/includes/js/dojox/io/proxy/tests/frag.xml b/includes/js/dojox/io/proxy/tests/frag.xml
new file mode 100644
index 0000000..6904bba
--- /dev/null
+++ b/includes/js/dojox/io/proxy/tests/frag.xml
@@ -0,0 +1,4 @@
+<response>
+<foo>This is the foo text node value</foo>
+<bar>This is the bar text node value</bar>
+</response>
diff --git a/includes/js/dojox/io/proxy/tests/xip.html b/includes/js/dojox/io/proxy/tests/xip.html
new file mode 100644
index 0000000..5a5ba5f
--- /dev/null
+++ b/includes/js/dojox/io/proxy/tests/xip.html
@@ -0,0 +1,62 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
+ "http://www.w3.org/TR/html4/strict.dtd">
+<html>
+<head>
+ <title>XHR IFrame Proxy Tests</title>
+ <style type="text/css">
+ @import "../../../../dojo/resources/dojo.css";
+ @import "../../../../dijit/themes/tundra/tundra.css";
+ @import "../../../../dijit/themes/dijit.css";
+ </style>
+
+ <script type="text/javascript" src="../../../../dojo/dojo.js"
+ djConfig="isDebug:true"></script>
+ <script type="text/javascript" src="../xip.js"></script>
+ <script type="text/javascript">
+ dojo.require("dojox.io.proxy.xip");
+
+ function testXmlGet(){
+/*
+ //Normal xhrGet call.
+ dojo.xhrGet({
+ url: "frag.xml",
+ handleAs: "xml",
+ load: function(result, ioArgs){
+ var foo = result.getElementsByTagName("foo").item(0);
+
+ dojo.byId("xmlGetOut").innerHTML = "Success: First foobar value is: " + foo.firstChild.nodeValue;
+ }
+ });
+*/
+
+ //xip xhrGet call.
+ dojo.xhrGet({
+ iframeProxyUrl: "../xip_server.html",
+ url: "tests/frag.xml",
+ handleAs: "xml",
+ load: function(result, ioArgs){
+ var foo = result.getElementsByTagName("foo").item(0);
+
+ dojo.byId("xmlGetOut").innerHTML = "Success: First foobar value is: " + foo.firstChild.nodeValue;
+ }
+ });
+
+ }
+
+ dojo.addOnLoad(function(){
+
+ });
+ </script>
+</head>
+<body class="tundra">
+
+<h1>XHR IFrame Proxy Tests</h1>
+<p>Run this test from a web server, not from local disk.</p>
+
+<p>
+<button onclick="testXmlGet()">Test XML GET</button>
+</p>
+<div id="xmlGetOut"></div>
+
+</body>
+</html>
diff --git a/includes/js/dojox/io/proxy/xip.js b/includes/js/dojox/io/proxy/xip.js
new file mode 100644
index 0000000..b88d910
--- /dev/null
+++ b/includes/js/dojox/io/proxy/xip.js
@@ -0,0 +1,441 @@
+if(!dojo._hasResource["dojox.io.proxy.xip"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojox.io.proxy.xip"] = true;
+dojo.provide("dojox.io.proxy.xip");
+
+dojo.require("dojo.io.iframe");
+dojo.require("dojox.data.dom");
+
+dojox.io.proxy.xip = {
+ //summary: Object that implements the iframe handling for XMLHttpRequest
+ //IFrame Proxying.
+ //description: Do not use this object directly. See the Dojo Book page
+ //on XMLHttpRequest IFrame Proxying:
+ //http://dojotoolkit.org/book/dojo-book-0-4/part-5-connecting-pieces/i-o/cross-domain-xmlhttprequest-using-iframe-proxy
+ //Usage of XHR IFrame Proxying does not work from local disk in Safari.
+
+ /*
+ This code is really focused on just sending one complete request to the server, and
+ receiving one complete response per iframe. The code does not expect to reuse iframes for multiple XHR request/response
+ sequences. This might be reworked later if performance indicates a need for it.
+
+ xip fragment identifier/hash values have the form:
+ #id:cmd:realEncodedMessage
+
+ id: some ID that should be unique among message fragments. No inherent meaning,
+ just something to make sure the hash value is unique so the message
+ receiver knows a new message is available.
+
+ cmd: command to the receiver. Valid values are:
+ - init: message used to init the frame. Sent as the first URL when loading
+ the page. Contains some config parameters.
+ - loaded: the remote frame is loaded. Only sent from xip_client.html to this module.
+ - ok: the message that this page sent was received OK. The next message may
+ now be sent.
+ - start: the start message of a block of messages (a complete message may
+ need to be segmented into many messages to get around the limitiations
+ of the size of an URL that a browser accepts.
+ - part: indicates this is a part of a message.
+ - end: the end message of a block of messages. The message can now be acted upon.
+ If the message is small enough that it doesn't need to be segmented, then
+ just one hash value message can be sent with "end" as the command.
+
+ To reassemble a segmented message, the realEncodedMessage parts just have to be concatenated
+ together.
+ */
+
+ xipClientUrl: ((dojo.config || djConfig)["xipClientUrl"]) || dojo.moduleUrl("dojox.io.proxy", "xip_client.html"),
+
+
+ //MSIE has the lowest limit for URLs with fragment identifiers,
+ //at around 4K. Choosing a slightly smaller number for good measure.
+ urlLimit: 4000,
+
+ _callbackName: (dojox._scopeName || "dojox") + ".io.proxy.xip.fragmentReceived",
+ _state: {},
+ _stateIdCounter: 0,
+ _isWebKit: navigator.userAgent.indexOf("WebKit") != -1,
+
+
+ send: function(/*Object*/facade){
+ //summary: starts the xdomain request using the provided facade.
+ //This method first does some init work, then delegates to _realSend.
+
+ var url = this.xipClientUrl;
+ //Make sure we are not dealing with javascript urls, just to be safe.
+ if(url.split(":")[0].match(/javascript/i) || facade._ifpServerUrl.split(":")[0].match(/javascript/i)){
+ return;
+ }
+
+ //Make xip_client a full URL.
+ var colonIndex = url.indexOf(":");
+ var slashIndex = url.indexOf("/");
+ if(colonIndex == -1 || slashIndex < colonIndex){
+ //No colon or we are starting with a / before a colon, so we need to make a full URL.
+ var loc = window.location.href;
+ if(slashIndex == 0){
+ //Have a full path, just need the domain.
+ url = loc.substring(0, loc.indexOf("/", 9)) + url; //Using 9 to get past http(s)://
+ }else{
+ url = loc.substring(0, (loc.lastIndexOf("/") + 1)) + url;
+ }
+ }
+ this.fullXipClientUrl = url;
+
+ //Set up an HTML5 messaging listener if postMessage exists.
+ //As of this writing, this is only useful to get Opera 9.25+ to work.
+ if(typeof document.postMessage != "undefined"){
+ document.addEventListener("message", dojo.hitch(this, this.fragmentReceivedEvent), false);
+ }
+
+ //Now that we did first time init, always use the realSend method.
+ this.send = this._realSend;
+ return this._realSend(facade); //Object
+ },
+
+ _realSend: function(facade){
+ //summary: starts the actual xdomain request using the provided facade.
+ var stateId = "XhrIframeProxy" + (this._stateIdCounter++);
+ facade._stateId = stateId;
+
+ var frameUrl = facade._ifpServerUrl + "#0:init:id=" + stateId + "&client="
+ + encodeURIComponent(this.fullXipClientUrl) + "&callback=" + encodeURIComponent(this._callbackName);
+
+ this._state[stateId] = {
+ facade: facade,
+ stateId: stateId,
+ clientFrame: dojo.io.iframe.create(stateId, "", frameUrl),
+ isSending: false,
+ serverUrl: facade._ifpServerUrl,
+ requestData: null,
+ responseMessage: "",
+ requestParts: [],
+ idCounter: 1,
+ partIndex: 0,
+ serverWindow: null
+ };
+
+ return stateId; //Object
+ },
+
+ receive: function(/*String*/stateId, /*String*/urlEncodedData){
+ /* urlEncodedData should have the following params:
+ - responseHeaders
+ - status
+ - statusText
+ - responseText
+ */
+ //Decode response data.
+ var response = {};
+ var nvPairs = urlEncodedData.split("&");
+ for(var i = 0; i < nvPairs.length; i++){
+ if(nvPairs[i]){
+ var nameValue = nvPairs[i].split("=");
+ response[decodeURIComponent(nameValue[0])] = decodeURIComponent(nameValue[1]);
+ }
+ }
+
+ //Set data on facade object.
+ var state = this._state[stateId];
+ var facade = state.facade;
+
+ facade._setResponseHeaders(response.responseHeaders);
+ if(response.status == 0 || response.status){
+ facade.status = parseInt(response.status, 10);
+ }
+ if(response.statusText){
+ facade.statusText = response.statusText;
+ }
+ if(response.responseText){
+ facade.responseText = response.responseText;
+
+ //Fix responseXML.
+ var contentType = facade.getResponseHeader("Content-Type");
+ if(contentType){
+ var mimeType = contentType.split(";")[0];
+ if(mimeType.indexOf("application/xml") == 0 || mimeType.indexOf("text/xml") == 0){
+ facade.responseXML = dojox.data.dom.createDocument(response.responseText, contentType);
+ }
+ }
+ }
+ facade.readyState = 4;
+
+ this.destroyState(stateId);
+ },
+
+ frameLoaded: function(/*String*/stateId){
+ var state = this._state[stateId];
+ var facade = state.facade;
+
+ var reqHeaders = [];
+ for(var param in facade._requestHeaders){
+ reqHeaders.push(param + ": " + facade._requestHeaders[param]);
+ }
+
+ var requestData = {
+ uri: facade._uri
+ };
+ if(reqHeaders.length > 0){
+ requestData.requestHeaders = reqHeaders.join("\r\n");
+ }
+ if(facade._method){
+ requestData.method = facade._method;
+ }
+ if(facade._bodyData){
+ requestData.data = facade._bodyData;
+ }
+
+ this.sendRequest(stateId, dojo.objectToQuery(requestData));
+ },
+
+ destroyState: function(/*String*/stateId){
+ var state = this._state[stateId];
+ if(state){
+ delete this._state[stateId];
+ var parentNode = state.clientFrame.parentNode;
+ parentNode.removeChild(state.clientFrame);
+ state.clientFrame = null;
+ state = null;
+ }
+ },
+
+ createFacade: function(){
+ if(arguments && arguments[0] && arguments[0].iframeProxyUrl){
+ return new dojox.io.proxy.xip.XhrIframeFacade(arguments[0].iframeProxyUrl);
+ }else{
+ return dojox.io.proxy.xip._xhrObjOld.apply(dojo, arguments);
+ }
+ },
+
+ //**** State-bound methods ****
+ sendRequest: function(stateId, encodedData){
+ var state = this._state[stateId];
+ if(!state.isSending){
+ state.isSending = true;
+
+ state.requestData = encodedData || "";
+
+ //Get a handle to the server iframe.
+ state.serverWindow = frames[state.stateId];
+ if (!state.serverWindow){
+ state.serverWindow = document.getElementById(state.stateId).contentWindow;
+ }
+
+ //Make sure we have contentWindow, but only do this for non-postMessage
+ //browsers (right now just opera is postMessage).
+ if(typeof document.postMessage == "undefined"){
+ if(state.serverWindow.contentWindow){
+ state.serverWindow = state.serverWindow.contentWindow;
+ }
+ }
+
+ this.sendRequestStart(stateId);
+ }
+ },
+
+ sendRequestStart: function(stateId){
+ //Break the message into parts, if necessary.
+ var state = this._state[stateId];
+ state.requestParts = [];
+ var reqData = state.requestData;
+ var urlLength = state.serverUrl.length;
+ var partLength = this.urlLimit - urlLength;
+ var reqIndex = 0;
+
+ while((reqData.length - reqIndex) + urlLength > this.urlLimit){
+ var part = reqData.substring(reqIndex, reqIndex + partLength);
+ //Safari will do some extra hex escaping unless we keep the original hex
+ //escaping complete.
+ var percentIndex = part.lastIndexOf("%");
+ if(percentIndex == part.length - 1 || percentIndex == part.length - 2){
+ part = part.substring(0, percentIndex);
+ }
+ state.requestParts.push(part);
+ reqIndex += part.length;
+ }
+ state.requestParts.push(reqData.substring(reqIndex, reqData.length));
+
+ state.partIndex = 0;
+ this.sendRequestPart(stateId);
+
+ },
+
+ sendRequestPart: function(stateId){
+ var state = this._state[stateId];
+
+ if(state.partIndex < state.requestParts.length){
+ //Get the message part.
+ var partData = state.requestParts[state.partIndex];
+
+ //Get the command.
+ var cmd = "part";
+ if(state.partIndex + 1 == state.requestParts.length){
+ cmd = "end";
+ }else if (state.partIndex == 0){
+ cmd = "start";
+ }
+
+ this.setServerUrl(stateId, cmd, partData);
+ state.partIndex++;
+ }
+ },
+
+ setServerUrl: function(stateId, cmd, message){
+ var serverUrl = this.makeServerUrl(stateId, cmd, message);
+ var state = this._state[stateId];
+
+ //Safari won't let us replace across domains.
+ if(this._isWebKit){
+ state.serverWindow.location = serverUrl;
+ }else{
+ state.serverWindow.location.replace(serverUrl);
+ }
+ },
+
+ makeServerUrl: function(stateId, cmd, message){
+ var state = this._state[stateId];
+ var serverUrl = state.serverUrl + "#" + (state.idCounter++) + ":" + cmd;
+ if(message){
+ serverUrl += ":" + message;
+ }
+ return serverUrl;
+ },
+
+ fragmentReceivedEvent: function(evt){
+ //summary: HTML5 document messaging endpoint. Unpack the event to see
+ //if we want to use it.
+ if(evt.uri.split("#")[0] == this.fullXipClientUrl){
+ this.fragmentReceived(evt.data);
+ }
+ },
+
+ fragmentReceived: function(frag){
+ var index = frag.indexOf("#");
+ var stateId = frag.substring(0, index);
+ var encodedData = frag.substring(index + 1, frag.length);
+
+ var msg = this.unpackMessage(encodedData);
+ var state = this._state[stateId];
+
+ switch(msg.command){
+ case "loaded":
+ this.frameLoaded(stateId);
+ break;
+ case "ok":
+ this.sendRequestPart(stateId);
+ break;
+ case "start":
+ state.responseMessage = "" + msg.message;
+ this.setServerUrl(stateId, "ok");
+ break;
+ case "part":
+ state.responseMessage += msg.message;
+ this.setServerUrl(stateId, "ok");
+ break;
+ case "end":
+ this.setServerUrl(stateId, "ok");
+ state.responseMessage += msg.message;
+ this.receive(stateId, state.responseMessage);
+ break;
+ }
+ },
+
+ unpackMessage: function(encodedMessage){
+ var parts = encodedMessage.split(":");
+ var command = parts[1];
+ encodedMessage = parts[2] || "";
+
+ var config = null;
+ if(command == "init"){
+ var configParts = encodedMessage.split("&");
+ config = {};
+ for(var i = 0; i < configParts.length; i++){
+ var nameValue = configParts[i].split("=");
+ config[decodeURIComponent(nameValue[0])] = decodeURIComponent(nameValue[1]);
+ }
+ }
+ return {command: command, message: encodedMessage, config: config};
+ }
+}
+
+//Replace the normal XHR factory with the proxy one.
+dojox.io.proxy.xip._xhrObjOld = dojo._xhrObj;
+dojo._xhrObj = dojox.io.proxy.xip.createFacade;
+
+/**
+ Using this a reference: http://www.w3.org/TR/XMLHttpRequest/
+
+ Does not implement the onreadystate callback since dojo.xhr* does
+ not use it.
+*/
+dojox.io.proxy.xip.XhrIframeFacade = function(ifpServerUrl){
+ //summary: XMLHttpRequest facade object used by dojox.io.proxy.xip.
+
+ //description: Do not use this object directly. See the Dojo Book page
+ //on XMLHttpRequest IFrame Proxying:
+ //http://dojotoolkit.org/book/dojo-book-0-4/part-5-connecting-pieces/i-o/cross-domain-xmlhttprequest-using-iframe-proxy
+ this._requestHeaders = {};
+ this._allResponseHeaders = null;
+ this._responseHeaders = {};
+ this._method = null;
+ this._uri = null;
+ this._bodyData = null;
+ this.responseText = null;
+ this.responseXML = null;
+ this.status = null;
+ this.statusText = null;
+ this.readyState = 0;
+
+ this._ifpServerUrl = ifpServerUrl;
+ this._stateId = null;
+}
+
+dojo.extend(dojox.io.proxy.xip.XhrIframeFacade, {
+ //The open method does not properly reset since Dojo does not reuse XHR objects.
+ open: function(/*String*/method, /*String*/uri){
+ this._method = method;
+ this._uri = uri;
+
+ this.readyState = 1;
+ },
+
+ setRequestHeader: function(/*String*/header, /*String*/value){
+ this._requestHeaders[header] = value;
+ },
+
+ send: function(/*String*/stringData){
+ this._bodyData = stringData;
+
+ this._stateId = dojox.io.proxy.xip.send(this);
+
+ this.readyState = 2;
+ },
+ abort: function(){
+ dojox.io.proxy.xip.destroyState(this._stateId);
+ },
+
+ getAllResponseHeaders: function(){
+ return this._allResponseHeaders; //String
+ },
+
+ getResponseHeader: function(/*String*/header){
+ return this._responseHeaders[header]; //String
+ },
+
+ _setResponseHeaders: function(/*String*/allHeaders){
+ if(allHeaders){
+ this._allResponseHeaders = allHeaders;
+
+ //Make sure ther are now CR characters in the headers.
+ allHeaders = allHeaders.replace(/\r/g, "");
+ var nvPairs = allHeaders.split("\n");
+ for(var i = 0; i < nvPairs.length; i++){
+ if(nvPairs[i]){
+ var nameValue = nvPairs[i].split(": ");
+ this._responseHeaders[nameValue[0]] = nameValue[1];
+ }
+ }
+ }
+ }
+});
+
+}
diff --git a/includes/js/dojox/io/proxy/xip_client.html b/includes/js/dojox/io/proxy/xip_client.html
new file mode 100644
index 0000000..c51a839
--- /dev/null
+++ b/includes/js/dojox/io/proxy/xip_client.html
@@ -0,0 +1,102 @@
+<!--
+ /*
+ Copyright (c) 2004-2008, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+ */
+-->
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+ <title></title>
+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8"></meta>
+ <!-- Security protection: uncomment the start and end script tags to enable. -->
+ <!-- script type="text/javascript" -->
+ // <!--
+
+ function pollHash(){
+ //Can't use location.hash because at least Firefox does a decodeURIComponent on it.
+ var urlParts = window.location.href.split("#");
+ if(urlParts.length == 2){
+ var newHash = urlParts[1];
+ if(newHash != xipCurrentHash){
+ try{
+ callMaster(xipStateId, newHash);
+ }catch(e){
+ //Make sure to not keep processing the error hash value.
+ xipCurrentHash = newHash;
+ throw e;
+ }
+ xipCurrentHash = newHash;
+ }
+ }
+ }
+
+ function unpackMessage(encodedMessage){
+ var parts = encodedMessage.split(":");
+ var command = parts[1];
+ encodedMessage = parts[2] || "";
+
+ var config = null;
+ if(command == "init"){
+ var configParts = encodedMessage.split("&");
+ config = {};
+ for(var i = 0; i < configParts.length; i++){
+ var nameValue = configParts[i].split("=");
+ config[decodeURIComponent(nameValue[0])] = decodeURIComponent(nameValue[1]);
+ }
+ }
+ return {command: command, message: encodedMessage, config: config};
+ }
+
+ //************** Init **************************
+ xipCurrentHash = "";
+
+ //Decode the init params
+ var fragId = window.location.href.split("#")[1];
+ var config = unpackMessage(fragId).config;
+
+ xipStateId = config.id;
+ xipMasterFrame = parent.parent;
+
+ //Set up an HTML5 messaging publisher if postMessage exists.
+ //As of this writing, this is only useful to get Opera 9.25+ to work.
+ if(typeof document.postMessage != "undefined"){
+ callMaster = function(stateId, message){
+ xipMasterFrame.document.postMessage(stateId + "#" + message);
+ }
+ }else{
+ var parts = config.callback.split(".");
+ xipCallbackObject = xipMasterFrame;
+ for(var i = 0; i < parts.length - 1; i++){
+ xipCallbackObject = xipCallbackObject[parts[i]];
+ }
+ xipCallback = parts[parts.length - 1];
+
+ callMaster = function(stateId, message){
+ xipCallbackObject[xipCallback](stateId + "#" + message);
+ }
+ }
+
+ //Call the master frame to let it know it is OK to start sending.
+ callMaster(xipStateId, "0:loaded");
+
+ //Start counter to inspect hash value.
+ setInterval(pollHash, 10);
+
+ // -->
+ <!-- </script> -->
+</head>
+<body>
+ <h4>The Dojo Toolkit -- xip_client.html</h4>
+
+ <p>This file is used for Dojo's XMLHttpRequest Iframe Proxy. This is the "client" file used
+ internally by dojox.io.proxy.xip.</p>
+</body>
+</html>
diff --git a/includes/js/dojox/io/proxy/xip_server.html b/includes/js/dojox/io/proxy/xip_server.html
new file mode 100644
index 0000000..01b7274
--- /dev/null
+++ b/includes/js/dojox/io/proxy/xip_server.html
@@ -0,0 +1,382 @@
+<!--
+ /*
+ Copyright (c) 2004-2008, The Dojo Foundation
+ All Rights Reserved.
+
+ Licensed under the Academic Free License version 2.1 or above OR the
+ modified BSD license. For more information on Dojo licensing, see:
+
+ http://dojotoolkit.org/community/licensing.shtml
+ */
+ Pieces taken from Dojo source to make this file stand-alone
+-->
+<html>
+<head>
+ <title></title>
+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8"></meta>
+ <script type="text/javascript" src="isAllowed.js"></script>
+ <!--
+ BY DEFAULT THIS FILE DOES NOT WORK SO THAT YOU DON'T ACCIDENTALLY EXPOSE
+ ALL OF YOUR XHR-ENABLED SERVICES ON YOUR SITE.
+
+ In order for this file to work, you need to uncomment the start and end script tags,
+ and you should define a function with the following signature:
+
+ function isAllowedRequest(request){
+ return false;
+ }
+
+ Return true out of the function if you want to allow the cross-domain request.
+
+ DON'T DEFINE THIS FUNCTION IN THIS FILE! Define it in a separate file called isAllowed.js
+ and include it in this page with a script tag that has a src attribute pointing to the file.
+ See the very first script tag in this file for an example. You do not have to place the
+ script file in the same directory as this file, just update the path above if you move it
+ somewhere else.
+
+ Customize the isAllowedRequest function to restrict what types of requests are allowed
+ for this server. The request object has the following properties:
+ - requestHeaders: an object with the request headers that are to be added to
+ the XHR request.
+ - method: the HTTP method (GET, POST, etc...)
+ - uri: The URI for the request.
+ - data: The URL-encoded data for the request. For a GET request, this would
+ be the querystring parameters. For a POST request, it wll be the
+ body data.
+
+ See xip_client.html for more info on the xip fragment identifier protocol.
+ -->
+
+ <!-- Security protection: uncomment the script tag to enable. -->
+ <!-- script type="text/javascript" -->
+ // <!--
+ //Core XHR handling taken from Dojo IO code.
+ dojo = {};
+ dojo.hostenv = {};
+ // These are in order of decreasing likelihood; this will change in time.
+ dojo.hostenv._XMLHTTP_PROGIDS = ['Msxml2.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.4.0'];
+
+ dojo.hostenv.getXmlhttpObject = function(){
+ var http = null;
+ var last_e = null;
+ try{ http = new XMLHttpRequest(); }catch(e){}
+ if(!http){
+ for(var i=0; i<3; ++i){
+ var progid = dojo.hostenv._XMLHTTP_PROGIDS[i];
+ try{
+ http = new ActiveXObject(progid);
+ }catch(e){
+ last_e = e;
+ }
+
+ if(http){
+ dojo.hostenv._XMLHTTP_PROGIDS = [progid]; // so faster next time
+ break;
+ }
+ }
+
+ /*if(http && !http.toString) {
+ http.toString = function() { "[object XMLHttpRequest]"; }
+ }*/
+ }
+
+ if(!http){
+ throw "xip_server.html: XMLHTTP not available: " + last_e;
+ }
+
+ return http;
+ }
+
+ dojo.setHeaders = function(http, headers){
+ if(headers) {
+ for(var header in headers) {
+ var headerValue = headers[header];
+ http.setRequestHeader(header, headerValue);
+ }
+ }
+ }
+
+ //MSIE has the lowest limit for URLs with fragment identifiers,
+ //at around 4K. Choosing a slightly smaller number for good measure.
+ xipUrlLimit = 4000;
+ xipIdCounter = 1;
+
+ function xipServerInit(){
+ xipStateId = "";
+ xipCurrentHash = "";
+ xipRequestMessage = "";
+ xipResponseParts = [];
+ xipPartIndex = 0;
+ }
+
+ function pollHash(){
+ //Can't use location.hash because at least Firefox does a decodeURIComponent on it.
+ var urlParts = window.location.href.split("#");
+ if(urlParts.length == 2){
+ var newHash = urlParts[1];
+ if(newHash != xipCurrentHash){
+ try{
+ messageReceived(newHash);
+ }catch(e){
+ //Make sure to not keep processing the error hash value.
+ xipCurrentHash = newHash;
+ throw e;
+ }
+ xipCurrentHash = newHash;
+ }
+ }
+ }
+
+ function messageReceived(encodedData){
+ var msg = unpackMessage(encodedData);
+
+ switch(msg.command){
+ case "ok":
+ sendResponsePart();
+ break;
+ case "start":
+ xipRequestMessage = "";
+ xipRequestMessage += msg.message;
+ setClientUrl("ok");
+ break;
+ case "part":
+ xipRequestMessage += msg.message;
+ setClientUrl("ok");
+ break;
+ case "end":
+ setClientUrl("ok");
+ xipRequestMessage += msg.message;
+ sendXhr();
+ break;
+ }
+ }
+
+ function sendResponse(encodedData){
+ //Break the message into parts, if necessary.
+ xipResponseParts = [];
+ var resData = encodedData;
+ var urlLength = xipClientUrl.length;
+ var partLength = xipUrlLimit - urlLength;
+ var resIndex = 0;
+
+ while((resData.length - resIndex) + urlLength > xipUrlLimit){
+ var part = resData.substring(resIndex, resIndex + partLength);
+ //Safari will do some extra hex escaping unless we keep the original hex
+ //escaping complete.
+ var percentIndex = part.lastIndexOf("%");
+ if(percentIndex == part.length - 1 || percentIndex == part.length - 2){
+ part = part.substring(0, percentIndex);
+ }
+ xipResponseParts.push(part);
+ resIndex += part.length;
+ }
+ xipResponseParts.push(resData.substring(resIndex, resData.length));
+
+ xipPartIndex = 0;
+ sendResponsePart();
+ }
+
+ function sendResponsePart(){
+ if(xipPartIndex < xipResponseParts.length){
+ //Get the message part.
+ var partData = xipResponseParts[xipPartIndex];
+
+ //Get the command.
+ var cmd = "part";
+ if(xipPartIndex + 1 == xipResponseParts.length){
+ cmd = "end";
+ }else if (xipPartIndex == 0){
+ cmd = "start";
+ }
+
+ setClientUrl(cmd, partData);
+ xipPartIndex++;
+ }else{
+ xipServerInit();
+ }
+ }
+
+ function setClientUrl(cmd, message){
+ var clientUrl = makeClientUrl(cmd, message);
+ //Safari won't let us replace across domains.
+ if(navigator.userAgent.indexOf("Safari") == -1){
+ xipClientWindow.location.replace(clientUrl);
+ }else{
+ xipClientWindow.location = clientUrl;
+ }
+ }
+
+ function makeClientUrl(cmd, message){
+ var clientUrl = xipClientUrl + "#" + (xipIdCounter++) + ":" + cmd;
+ if(message){
+ clientUrl += ":" + message;
+ }
+ return clientUrl
+ }
+
+ function xhrDone(xhr){
+ /* Need to pull off and return the following data:
+ - responseHeaders
+ - status
+ - statusText
+ - responseText
+ */
+ var response = {};
+
+ if(typeof(xhr.getAllResponseHeaders) != "undefined"){
+ var allHeaders = xhr.getAllResponseHeaders();
+ if(allHeaders){
+ response.responseHeaders = allHeaders;
+ }
+ }
+
+ if(xhr.status == 0 || xhr.status){
+ response.status = xhr.status;
+ }
+
+ if(xhr.statusText){
+ response.statusText = xhr.statusText;
+ }
+
+ if(xhr.responseText){
+ response.responseText = xhr.responseText;
+ }
+
+ //Build a string of the response object.
+ var result = "";
+ var isFirst = true;
+ for (var param in response){
+ if(isFirst){
+ isFirst = false;
+ }else{
+ result += "&";
+ }
+ result += param + "=" + encodeURIComponent(response[param]);
+ }
+ sendResponse(result);
+ }
+
+ function sendXhr(){
+ var request = {};
+ var nvPairs = xipRequestMessage.split("&");
+ var i = 0;
+ var nameValue = null;
+ for(i = 0; i < nvPairs.length; i++){
+ if(nvPairs[i]){
+ var nameValue = nvPairs[i].split("=");
+ request[decodeURIComponent(nameValue[0])] = decodeURIComponent(nameValue[1]);
+ }
+ }
+
+ //Split up the request headers, if any.
+ var headers = {};
+ if(request.requestHeaders){
+ nvPairs = request.requestHeaders.split("\r\n");
+ for(i = 0; i < nvPairs.length; i++){
+ if(nvPairs[i]){
+ nameValue = nvPairs[i].split(": ");
+ headers[decodeURIComponent(nameValue[0])] = decodeURIComponent(nameValue[1]);
+ }
+ }
+
+ request.requestHeaders = headers;
+ }
+
+ if(isAllowedRequest(request)){
+
+ //The request is allowed, so set up the XHR object.
+ var xhr = dojo.hostenv.getXmlhttpObject();
+
+ //Start timer to look for readyState.
+ var xhrIntervalId = setInterval(function(){
+
+ if(xhr.readyState == 4){
+ clearInterval(xhrIntervalId);
+ xhrDone(xhr);
+ }
+ }, 10);
+
+ //Actually start up the XHR request.
+ xhr.open(request.method, request.uri, true);
+ dojo.setHeaders(xhr, request.requestHeaders);
+
+ var content = "";
+ if(request.data){
+ content = request.data;
+ }
+
+ try{
+ xhr.send(content);
+ }catch(e){
+ if(typeof xhr.abort == "function"){
+ xhr.abort();
+ xhrDone({status: 404, statusText: "xip_server.html error: " + e});
+ }
+ }
+ }
+ }
+
+ function unpackMessage(encodedMessage){
+ var parts = encodedMessage.split(":");
+ var command = parts[1];
+ encodedMessage = parts[2] || "";
+
+ var config = null;
+ if(command == "init"){
+ var configParts = encodedMessage.split("&");
+ config = {};
+ for(var i = 0; i < configParts.length; i++){
+ var nameValue = configParts[i].split("=");
+ config[decodeURIComponent(nameValue[0])] = decodeURIComponent(nameValue[1]);
+ }
+ }
+ return {command: command, message: encodedMessage, config: config};
+ }
+
+ function onServerLoad(){
+ xipServerInit();
+
+ //Decode the init params
+ var config = unpackMessage(window.location.href.split("#")[1]).config;
+
+ xipStateId = config.id;
+ xipClientUrl = config.client;
+
+ //Make sure we don't have a javascript: url, just for good measure.
+ if(xipClientUrl.split(":")[0].match(/javascript/i)){
+ throw "Invalid client URL";
+ }
+ if(!xipStateId.match(/^XhrIframeProxy[0-9]+$/)){
+ throw "Invalid state ID";
+ }
+
+ setInterval(pollHash, 10);
+
+ var serverUrl = window.location.href.split("#")[0];
+ document.getElementById("iframeHolder").innerHTML = '<iframe name="'
+ + xipStateId + '_clientEndPoint'
+ + '" src="javascript:false">'
+ + '</iframe>';
+ xipClientWindow = document.getElementsByTagName("iframe")[0];
+ xipClientWindow.src = makeClientUrl("init", 'id=' + xipStateId + "&callback=" + encodeURIComponent(config.callback));
+ if(xipClientWindow.contentWindow){
+ xipClientWindow = xipClientWindow.contentWindow;
+ }
+ }
+
+ if(typeof(window.addEventListener) == "undefined"){
+ window.attachEvent("onload", onServerLoad);
+ }else{
+ window.addEventListener('load', onServerLoad, false);
+ }
+ // -->
+ <!-- </script> -->
+</head>
+<body>
+ <h4>The Dojo Toolkit -- xip_server.html</h4>
+
+ <p>This file is used for Dojo's XMLHttpRequest Iframe Proxy. This is the the file
+ that should go on the server that will actually be doing the XHR request.</p>
+ <div id="iframeHolder"></div>
+</body>
+</html>