You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
438 lines
13 KiB
JavaScript
438 lines
13 KiB
JavaScript
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];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
});
|