author | williamt <williamt> | 2007-01-05 10:10:55 (UTC) |
---|---|---|
committer | williamt <williamt> | 2007-01-05 10:10:55 (UTC) |
commit | d85adfb349b3c7a988bec21fcbad86f5f98c70de (patch) (side-by-side diff) | |
tree | b0bff7d20e03d2e4ba4bfb3309059930006ab927 /src | |
parent | c4b3096e166a0a9a60fd27c8f2dc06e688f13172 (diff) | |
download | foxri-d85adfb349b3c7a988bec21fcbad86f5f98c70de.zip foxri-d85adfb349b3c7a988bec21fcbad86f5f98c70de.tar.gz foxri-d85adfb349b3c7a988bec21fcbad86f5f98c70de.tar.bz2 |
* Updated for Firefox 2REL_1_1_2upstream/master
-rwxr-xr-x | src/chrome/content/foxri.xul | 4 | ||||
-rwxr-xr-x | src/components/xriProtocolHandler.js | 10 | ||||
-rwxr-xr-x | src/install.rdf | 4 |
3 files changed, 6 insertions, 12 deletions
diff --git a/src/chrome/content/foxri.xul b/src/chrome/content/foxri.xul index dc1cc37..785cc0c 100755 --- a/src/chrome/content/foxri.xul +++ b/src/chrome/content/foxri.xul @@ -1,32 +1,28 @@ <?xml version="1.0"?>
<?xml-stylesheet href="foxri.css" type="text/css"?>
<overlay id="foxri" xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
<!--
<script type="application/x-javascript" src="chrome://foxri/content/xrdsHandler.js"/>
-->
<script>
function xriFix(event)
{
var txt = gURLBar.value;
if (/^(=|@|!)\S+/.test(txt)) {
gURLBar.value = "xri://" + txt;
}
}
</script>
- <toolbaritem id="urlbar-container">
<textbox id="urlbar" ontextentered="xriFix(); return handleURLBarCommand(param);" />
- </toolbaritem>
- <toolbaritem id="go-container">
<toolbarbutton id="go-button" oncommand="xriFix(); return handleURLBarCommand(event);" />
- </toolbaritem>
</overlay>
diff --git a/src/components/xriProtocolHandler.js b/src/components/xriProtocolHandler.js index 7046cde..1105874 100755 --- a/src/components/xriProtocolHandler.js +++ b/src/components/xriProtocolHandler.js @@ -1,1060 +1,1058 @@ /***********************************************************
constants
***********************************************************/
// The interface we implement - nsIProtocolHandler
const nsIProtocolHandler = Components.interfaces.nsIProtocolHandler;
// Interfaces that we require
const nsISupports = Components.interfaces.nsISupports;
const nsIIOService = Components.interfaces.nsIIOService;
const nsIURI = Components.interfaces.nsIURI;
const nsIURL = Components.interfaces.nsIURL;
const nsIRequest = Components.interfaces.nsIRequest;
const nsIRequestObserver = Components.interfaces.nsIRequestObserver;
const nsIChannel = Components.interfaces.nsIChannel;
const nsIHttpChannel = Components.interfaces.nsIHttpChannel;
const nsIStreamListener = Components.interfaces.nsIStreamListener;
// UUID uniquely identifying our component
// You can get from: http://kruithof.xs4all.nl/uuid/uuidgen here
const CLASS_ID = Components.ID("{ea00b610-215a-11db-a98b-0800200c9a66}");
// textual unique identifier
const CONTRACT_ID = "@mozilla.org/network/protocol;1?name=xri";
// Components that we require
const CID_URI = "@mozilla.org/network/simple-uri;1";
const kIOSERVICE_CID_STR = "{9ac9e770-18bc-11d3-9337-00104ba0fd40}";
const CID_URL = "@mozilla.org/network/standard-url;1";
// description
const CLASS_NAME = "XRI Protocol Handler";
const PROXY_URI = "http://xri.net/";
const XP_ANY_TYPE = 0;
const XP_NUMBER_TYPE = 1;
const XP_STRING_TYPE = 2;
const XP_BOOLEAN_TYPE = 3;
const XP_UNORDERED_NODE_ITERATOR_TYPE = 4;
const XP_ORDERED_NODE_ITERATOR_TYPE = 5;
const XP_UNORDERED_NODE_SNAPSHOT_TYPE = 6;
const XP_ORDERED_NODE_SNAPSHOT_TYPE = 7;
const XP_ANY_UNORDERED_NODE_TYPE = 8;
const XP_FIRST_ORDERED_NODE_TYPE = 9;
var SERVICE_CLASSES = {
'xri://+i-service*(+contact)*($v*1.0)': 'i-contact',
'http://openid.net/signon/1.0': 'openid',
'xri://$res*auth*($v*2.0)': 'res-auth',
'xri://+i-service*(+authn)*(+saml)*($v*1.0)': 'authn-saml',
'xri://+i-service*(+metadata)*(+saml)*($v*1.0)' : 'metadata-saml',
'xri://+i-service*(+forwarding)*($v*1.0)': 'i-forwarding'
};
const HTML_HEAD = "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n\
<html xmlns=\"http://www.w3.org/1999/xhtml\">\n\
<head>\n\
<title>FoXRI Explorer - #QXRI#</title>\n\
<link href=\"chrome://foxri/content/foxri_explorer.css\" rel=\"stylesheet\" type=\"text/css\" />\n\
<body>\n\
<h1>FoXRI Explorer</h1>\n\
<div id=\"explorer_body\">\n";
const HTML_FOOT = "</div>\n\
</body>\n\
</html>";
/// Generic object method wrapper
function methodWrapper(obj, method)
{
return (
function() {
/* pass it this inner closure's arguments */
obj[method](arguments);
}
);
}
/// XRDS utility functions
var nsResolver = {
lookupNamespaceURI: function(prefix)
{
if (prefix == "xrds")
return "xri://$xrds";
else if (prefix == "xrd")
return "xri://$xrd*($v*2.0)";
return "";
}
};
function runExpr(doc, context, expr, returnType)
{
if (!returnType)
returnType = XP_ANY_TYPE;
var res = doc.evaluate(expr, context, nsResolver, returnType, null);
return res;
}
function getNumeric(doc, context, expr)
{
var res = runExpr(doc, context, expr, XP_NUMBER_TYPE);
if (res)
return res.numberValue;
return null;
}
function getString(doc, context, expr)
{
// var res = runExpr(doc, context, expr, XPathResult.STRING_TYPE);
var res = runExpr(doc, context, expr, XP_STRING_TYPE);
if (res)
return res.stringValue;
return null;
}
function getNode(doc, context, expr)
{
var res = runExpr(doc, context, expr, XP_FIRST_ORDERED_NODE_TYPE);
if (res)
return res.singleNodeValue;
return null;
}
function getFinalXRD(doc)
{
var lastNode = doc.firstChild;
while (true) {
var node = getNode(doc, lastNode, "xrds:XRDS[position()=last()]");
if (!node)
break;
lastNode = node;
}
return getNode(doc, lastNode, "xrd:XRD[position()=last()]");
}
function isIName(xri)
{
if (xri.match('^xri://.!', 'i')) {
return false;
}
if (xri.match('^.!', 'i')) {
return false;
}
return true;
}
function arraySearch(a, re)
{
var returnArr = new Array();
var i;
for (i = 0; i < a.length; i++) {
if (a[i].match(re)) {
returnArr.push(a[i]);
}
}
return returnArr;
}
function renderService(srv, doc, qxri)
{
var html_types = '';
var html_paths = '';
var html_mediatypes = '';
var html_uris = '';
var html_actions = '';
var serviceName = friendlyServiceName(null);
var serviceType; // the last non-null Type
var knownServiceType; // first recognized service type
// get the types
var res = runExpr(doc, srv, "xrd:Type/text()");
var t;
while (t = res.iterateNext()) {
if (t.nodeValue) {
if (!knownServiceType && isKnownServiceType(t.nodeValue)) {
knownServiceType = t.nodeValue;
}
serviceType = t.nodeValue;
html_types += "<strong>Type:</strong> " + t.nodeValue + "<br/>";
}
}
// get the paths
res = runExpr(doc, srv, "xrd:Path/text()");
var p;
var qxri_prefix = qxri;
if (qxri_prefix.charAt(qxri_prefix.length - 1) != '/') {
qxri_prefix += '/';
}
while (p = res.iterateNext()) {
if (p.nodeValue) {
html_paths += "<strong>Path:</strong> " + p.nodeValue
+ " [ <tt><a href=\"" + qxri_prefix + p.nodeValue + "\">"
+ qxri_prefix + p.nodeValue + "</a></tt> ]"
+ "<br/>\n";
}
}
// get the mediatypes
mediaTypes = new Array();
res = runExpr(doc, srv, "xrd:MediaType/text()");
var m;
while (m = res.iterateNext()) {
if (!knownServiceType) {
var srvType = guessServiceTypeByMime(m.nodeValue);
knownServiceType = srvType? srvType : null;
}
mediaTypes.push(m.nodeValue);
if (m.nodeValue) {
html_mediatypes += "<strong>Media Type:</strong> " + m.nodeValue + "<br/>";
}
}
res = runExpr(doc, srv, "xrd:URI/text()");
var u;
while (u = res.iterateNext()) {
if (!u.nodeValue)
continue;
var srvType = guessServiceTypeByURI(u.nodeValue);
if (!knownServiceType) {
knownServiceType = srvType;
}
html_uris += "<div class=\"" + getServiceClass(srvType) + "\">";
var linkContent = u.nodeValue;
var uriParts = u.nodeValue.match('^(.*):(.*)$');
if (!uriParts)
continue;
if (uriParts[1] == 'data') {
uriParts = uriParts[2].match('^(.*/.*),(.*)');
if (uriParts && uriParts[1].match('^image/', 'i')) {
linkContent = "<img src=\"" + u.nodeValue + "\"/>";
}
else if (uriParts) {
linkContent = uriParts[1] + " data";
}
}
else if (uriParts[1] == 'skype') {
uriParts = uriParts[2].match('^(.*)\\?(.*)');
if (uriParts) {
if (uriParts[2] == "call") {
linkContent = "<img src=\"chrome://foxri/content/skype_call_large.png\" alt=\"Call " + uriParts[1] + "\"/>";
}
else if (uriParts[2] == "chat") {
linkContent = "<img src=\"chrome://foxri/content/skype_chat_large.png\" alt=\"Chat with " + uriParts[1] + "\"/>";
}
else if (uriParts[2] == "add") {
linkContent = "<img src=\"chrome://foxri/content/skype_add_large.png\" alt=\"Add " + uriParts[1] + " to Skype\"/>";
}
}
}
else if (uriParts[1] == 'aim') {
uriParts = uriParts[2].match('^(.*)\\?.*screenname=([^&]*)', 'i');
if (uriParts) {
linkContent = "<img src=\"chrome://foxri/content/aim_logo.gif\" alt=\"Chat with " + uriParts[2] + "\"/> Chat with " + uriParts[2];
}
}
html_uris += "<a href=\""+u.nodeValue+"\">"
+ linkContent + "</a>";
html_uris += "</div>";
}
var html = "<div class=\"service srv_" + getServiceClass(knownServiceType) + "\">\n";
html += html_types;
html += html_paths;
html += html_mediatypes;
if (html_uris) {
html += "<strong>URI(s):</strong><br/>\n";
html += html_uris;
}
html += "</div>";
return html;
}
function isKnownServiceType(type)
{
if (type.toLowerCase() in SERVICE_CLASSES) {
return true;
}
return false;
}
function getServiceClass(type)
{
- if (isKnownServiceType(type)) {
+ if (type && isKnownServiceType(type)) {
return SERVICE_CLASSES[type.toLowerCase()];
}
return type;
}
function guessServiceTypeByURI(uri)
{
if (uri == null || uri == "") {
return "unknown";
}
if (uri.match(/^https?:/i)) {
return "www";
}
else if (uri.match(/^skype:/i)) {
return "skype";
}
else if (uri.match(/^aim:/i)) {
return "aim";
}
else if (uri.match(/^xmpp:/i)) {
return "jabber";
}
else if (uri.match(/^tel:/i)) {
return "tel";
}
else if (uri.match(/^callto:/i)) {
return "callto";
}
else if (uri.match(/^telnet:/i)) {
return "telnet";
}
else if (uri.match(/^news:/i)) {
return "news";
}
else if (uri.match(/^nntp:/i)) {
return "nntp";
}
else if (uri.match(/^ftp:/i)) {
return "ftp";
}
else if (uri.match(/^mailto:/i)) {
return "email";
}
else if (uri.match(/^urn:/i)) {
return "urn";
}
else if (uri.match(/^data:/i)) {
return "data";
}
else if (uri.match(/^feed:/i)) {
return "feed";
}
return "unknown";
}
function guessServiceTypeByMime(mimeType)
{
if (mimeType.match(/^application\/(rss|atom)\+xml/i)) {
dump("feed detected!\n");
return "feed";
}
else if (mimeType.match(/^image\//i)) {
return "image";
}
return null;
}
function friendlyServiceName(srvType, uri)
{
if (srvType && srvType == "xri://+i-service*(+contact)*($v*1.0)") {
return "Contact Service";
}
else if (srvType && srvType == "http://openid.net/signon/1.0") {
return "OpenID Authentication Service";
}
else if (srvType && srvType == "xri://$res*auth*($v*2.0)") {
return "Authority Resolution Service";
}
else {
if (uri == null) {
return "Generic Service";
}
if (uri.match(/^https?:/i)) {
return "Web Link";
}
else if (uri.match(/^skype:/i)) {
var user = uri.substring("skype:".length, uri.indexOf('?'));
return "Skype <a href=\"" + uri + "\"><img src=\"chrome://foxri/content/skype_call.png\"></a>";
}
else if (uri.match(/^mailto:/i)) {
var qmark = uri.indexOf('?');
var email = (qmark == -1)?
uri.substr("mailto:".length) :
uri.substring("mailto:".length, qmark);
return "Email (address: " + email + ")";
}
else if (srvType != null) {
return srvType; // return verbatim
}
return "Generic Service";
}
}
function subHTML(template, vars)
{
for (key in vars) {
template = template.replace(key, vars[key], 'g');
}
return template;
}
/// Given the completed XMLHttpRequest object, renders the XRDS
function renderXRDS(xmlDoc)
{
var x = xmlDoc;
var qxri = getString(x, x, "/xrds:XRDS/@ref");
var html = subHTML(HTML_HEAD, { '#QXRI#': qxri });
// TODO: render parents as well
var lastNode = getFinalXRD(x);
if (lastNode) {
var stat = getString(x, lastNode, "xrd:Status/@code");
if (stat == "100") {
html += "<h3>Exploring <strong>" + qxri + "</strong></h3>";
}
else {
var msg = getString(x, lastNode, "xrd:Status/text()");
html += "<h3 class=\"error\"><strong>" + qxri + "</strong> failed to resolve (reason: " + stat + " - " + msg + ")</h3>";
}
html += "<br/>";
var services = runExpr(x, lastNode, "xrd:Service");
var s;
var count = getNumeric(x, lastNode, "count(xrd:Service)");
if (count > 0) {
while (s = services.iterateNext()) {
count++;
html += renderService(s, x, qxri);
}
}
else if (stat == '222') {
var xriType = isIName(qxri)? 'I-name' : 'I-number';
html += "<p class='error'>" + xriType + " does not exist.</p>\n";
}
else {
html += "<p>No service has been configured for this XRI</p>";
}
}
html += "</html>";
return html;
}
/***********************************************************
XriServiceExplorer class definition
***********************************************************/
function XRIChannel(uri) {
this.URI = uri;
var r = uri.spec.indexOf('#');
if (r >= 0) {
this.qxri = uri.spec.substring(0, r);
this.fragment = uri.spec.substring(r);
}
else {
this.qxri = uri.spec;
}
};
XRIChannel.prototype = {
fragment: null,
/* private fields used internally */
qxri: null,
xmlRequest: null,
renderedHTML: null,
scriptableInStream: null,
buf: null,
mChannel: null,
copyFields: function(request)
{
dump("copyFields(loadFlags=" + request.loadFlags + ")\n");
dump("loadGroup = " + request.loadGroup + "\n");
dump("notificationCallbacks = " + request.notificationCallbacks + "\n");
// copy request fields
this.loadFlags = request.loadFlags;
this.loadGroup = request.loadGroup;
this.name = request.name;
this.status = request.status;
var channel = request.QueryInterface(nsIChannel);
if (channel) {
this.contentCharset = channel.contentCharset;
this.contentLength = channel.contentLength;
this.contentType = channel.contentType; // XXX
this.contentType = "text/html";
this.notificationCallbacks = channel.notificationCallbacks;
this.originalURI = this.originalURI;
this.URI = this.URI;
this.owner = channel.owner;
this.securityInfo = channel.securityInfo;
channel = channel.QueryInterface(nsIHttpChannel);
if (channel) {
this.allowPipelining = channel.allowPipelining;
this.redirectionLimit = channel.redirectionLimit;
this.referrer = channel.referrer;
this.requestMethod = channel.requestMethod;
this.requestSucceeded = channel.requestSucceeded;
this.responseStatus = channel.responseStatus;
this.responseStatusText = channel.responseStatusText;
}
}
},
/* nsIStreamListener */
asyncOpenListener: null,
/* nsISupports (but we really don't care) */
asyncOpenContext: null,
/* has the XML finished loading? */
loadDone: false,
/* public fields (nsIStreamListener implementation) */
onDataAvailable : function(request, ctx, inputStream, offset, count)
{
dump("\nonDataAvailable, offset=" + offset + ", count=" + count + "\n");
// XXX
/*
this.copyFields(request);
this.asyncOpenListener.onDataAvailable(this, this.asyncOpenContext, inputStream, offset, count);
return;
*/
if (offset == 0) {
this.scriptableInStream.init(inputStream);
}
this.buf += this.scriptableInStream.read(count);
if (!request.isPending()) {
dump("request finished, buf = " + this.buf + "\n");
this.scriptableInStream = null;
}
else {
dump("request pending...\n");
dump("buf so far = " + this.buf + "\n");
}
},
/* public fields (nsIRequestObserver implementation) */
onStartRequest : function(request, ctx)
{
dump("\nonStartRequest called\n");
// XXX
this.copyFields(request);
this.asyncOpenListener.onStartRequest(this, this.asyncOpenContext);
},
onStopRequest : function(request, ctx, status)
{
dump("\nonStopRequest called - status " + status + "\n");
// XXX
/*
this.asyncOpenListener.onStopRequest(this, this.asyncOpenContext, status);
return;
*/
this.copyFields(request);
this.loadDone = true;
if (status == 0) {
var domParser = Components.classes["@mozilla.org/xmlextras/domparser;1"].createInstance(Components.interfaces.nsIDOMParser);
var xmlDoc = domParser.parseFromString(this.buf, "text/xml");
// make fake inputstream
var renderedHTML = renderXRDS(xmlDoc);
this.contentCharset = "UTF-8";
this.contentLength = renderedHTML.length;
this.contentType = "text/html";
dump("rendered HTML = \n" + renderedHTML + "\n");
dump("\nCalling asyncOpenListener.onStartRequest\n\n");
var strIStream = Components.classes["@mozilla.org/io/string-input-stream;1"].createInstance(Components.interfaces.nsIStringInputStream);
if (strIStream) {
strIStream.setData(renderedHTML, renderedHTML.length);
/*
strIStream.setData(this.buf, this.buf.length);
*/
dump("\nleftovers in string-input-stream = " + strIStream.available() + "\n");
dump("\nCalling asyncOpenListener.onDataAvailable\n\n");
this.asyncOpenListener.onDataAvailable(this, this.asyncOpenContext, strIStream, 0, renderedHTML.length);
/*
this.asyncOpenListener.onDataAvailable(this, this.asyncOpenContext, strIStream, 0, this.buf.length);
*/
dump("\nleftovers in string-input-stream = " + strIStream.available() + "\n");
}
}
else {
dump("\nStatus = " + status + "\n");
dump("Calling asyncOpenListener.onStartRequest\n\n");
this.asyncOpenListener.onStartRequest(this, this.asyncOpenContext);
}
dump("stopping request for underlying asyncOpenListener\n");
this.asyncOpenListener.onStopRequest(this, this.asyncOpenContext, status);
// copied from nsIWyciwygChannel
this.asyncOpenListener = null;
this.asyncOpenContext = null;
/*
if (this.loadGroup) {
this.loadGroup.removeRequest(request, null, status);
}
*/
this.notificationCallbacks = null;
this.mChannel = null;
dump("stopped request\n");
},
/* public fields (nsIInputStream implementation) */
available: function()
{
dump("nsIInputStream::available called\n");
return renderedHTML.length;
},
close: function()
{
dump("nsIInputStream::close called\n");
},
isNonBlocking: function() {
dump("nsIInputStream::isNonBlocking called\n");
return true;
},
read: function() { dump("nsIInputStream::read() called!!!\n"); },
/* public fields (nsIRequest implmentation) */
loadFlags: 0,
loadGroup: null,
name: "xri://request",
status: 0,
cancel: function(status) { dump("\ncancel called...\n"); },
isPending: function() {
dump("isPending called\n\n");
return !this.loadDone;
},
resume: function() { dump("resume called\n"); },
suspend: function() { dump("suspend called\n"); },
/* public fields (nsIChannel implmentation) */
contentCharset: null,
contentLength: -1,
contentType: null,
notificationCallbacks: null,
originalURI: null,
owner: null,
securityInfo: null,
URI: null,
open: function()
{
dump("open not supporteD!!!!!!\n");
},
asyncOpen: function(listener, context)
{
dump("asyncOpen called!!!!!!\n");
this.asyncOpenListener = listener;
this.asyncOpenContext = context;
var hxri = PROXY_URI + this.qxri
+ "?_xrd_r=application/xrds%2Bxml;sep=false";
var ioService = Components.classesByID[kIOSERVICE_CID_STR].getService();
ioService = ioService.QueryInterface(nsIIOService);
var channel = ioService.newChannel(hxri, null, null);
if (this.scriptableInStream) {
dump("Hey! You can't possibly be reusing this handler?!\n");
return;
}
dump("making scriptableInStream\n");
this.scriptableInStream = Components.classes["@mozilla.org/scriptableinputstream;1"]
.createInstance(Components.interfaces.nsIScriptableInputStream);
this.buf = '';
dump("notificationCallbacks = " + this.notificationCallbacks + "\n");
dump("loadFlags = " + this.loadFlags + "\n");
dump("loadGroup = " + this.loadGroup + "\n");
dump("owner = " + this.owner + "\n");
dump("securityInfo = " + this.securityInfo + "\n");
// these nsIRequest attributes must be copied to the stub
// channel that we created
channel.notificationCallbacks = this.notificationCallbacks;
channel.loadGroup = this.loadGroup;
channel.loadFlags = this.loadFlags;
this.mChannel = channel;
channel.asyncOpen(this, null);
},
-/* public fields (nsIChannel implmentation) */
+/* public fields (nsIChannel implementation) */
allowPipelining: false,
redirectionLimit: 5,
referrer: "",
requestMethod: "GET",
requestSucceeded: true,
responseStatus: 200,
responseStatusText: "OK",
getRequestHeader: function(header) {
dump("getRequestHeader(" + header + ")\n");
var httpChannel = this.mChannel.QueryInterface(nsIHttpChannel);
try {
var val = httpChannel.getRequestHeader(header);
dump("getRequestHeader(" + header + ") = " + val + "\n");
return val;
}
catch (e) {
+ dump("getRequestHeader - got exception: " + e + "\n");
throw e;
}
},
getResponseHeader: function(header) {
dump("getResponseHeader(" + header + ")\n");
var httpChannel = this.mChannel.QueryInterface(nsIHttpChannel);
try {
var val = httpChannel.getResponseHeader(header);
dump("getResponseHeader(" + header + ") = " + val + "\n");
return val;
}
catch (e) {
+ dump("getResponseHeader - got exception: " + e + "\n");
throw e;
}
-/* XXX
- if (header == "Content-Type")
- return "text/html";
-*/
return null;
},
isNoCacheResponse: function() {
dump("isNoCacheResponse()\n");
var httpChannel = this.mChannel.QueryInterface(nsIHttpChannel);
return httpChannel.isNoCacheResponse();
},
isNoStoreResponse: function() {
dump("isNoStoreResponse()\n");
var httpChannel = this.mChannel.QueryInterface(nsIHttpChannel);
return httpChannel.isNoStoreResponse();
return true;
},
setRequestHeader: function(header, value, merge) {
dump("setRequestHeader(" + header + ", " + value + ")\n");
var httpChannel = this.mChannel.QueryInterface(nsIHttpChannel);
return httpChannel.setRequestHeader(header, value, merge);
},
setResponseHeader: function(header, value, merge) {
dump("setResponseHeader(" + header + ", " + value + ")\n");
var httpChannel = this.mChannel.QueryInterface(nsIHttpChannel);
return httpChannel.setResponseHeader(header, value, merge);
},
visitRequestHeaders: function(visitor) {
dump("visitRequestHeaders()\n");
},
visitResponseHeaders: function(visitor) {
dump("visitResponseHeaders()\n");
},
QueryInterface: function(iid)
{
dump("QI.. \n");
if (iid.equals(nsIChannel))
dump("QI(nsIChannel)\n");
else if (iid.equals(nsIHttpChannel))
dump("QI(nsIHttpChannel)\n");
else if (iid.equals(Components.interfaces.nsIUploadChannel))
dump("QI(nsIUploadChannel) - not supported\n");
else if (iid.equals(Components.interfaces.nsICachingChannel))
dump("QI(nsICachingChannel) - not supported\n");
else if (iid.equals(Components.interfaces.nsIClassInfo))
dump("QI(nsIClassInfo) - not supported\n");
else if (iid.equals(Components.interfaces.nsISecurityCheckedComponent))
dump("QI(nsISecurityCheckedComponent) - not supported\n");
else if (iid.equals(Components.interfaces.nsIWyciwygChannel))
dump("QI(nsIWyciwygChannel) - not supported\n");
else if (iid.equals(Components.interfaces.nsIMultiPartChannel))
dump("QI(nsIMultiPartChannel) - not supported\n");
else if (iid.equals(Components.interfaces.nsIHttpChannelInternal))
dump("QI(nsIHttpChannelInternal) - not supported\n");
else if (iid.equals(Components.interfaces.nsIWritablePropertyBag2))
dump("QI(nsIWritablePropertyBag2) - not supported\n");
else if (iid.equals(nsIRequest))
dump("QI(nsIRequest)\n");
else if (iid.equals(nsIRequestObserver))
dump("QI(nsIRequestObserver)\n");
else if (iid.equals(nsISupports))
dump("QI(nsISupports)\n");
else if (iid.equals(nsIStreamListener))
dump("QI(nsIStreamListener)\n");
else
dump("unknown " + iid + "\n");
if (iid.equals(nsISupports) ||
iid.equals(nsIRequest) ||
iid.equals(nsIRequestObserver) ||
iid.equals(nsIChannel) ||
iid.equals(nsIHttpChannel) ||
iid.equals(nsIStreamListener)
) {
return this;
}
throw Components.results.NS_ERROR_NO_INTERFACE;
}
};
/***********************************************************
XriProtocolHandler class definition
***********************************************************/
//class constructor
function XriProtocolHandler() {
};
// class definition
XriProtocolHandler.prototype = {
defaultPort: 80, // HTTP
protocolFlags : nsIProtocolHandler.ALLOWS_PROXY | nsIProtocolHandler.ALLOWS_PROXY_HTTP,
scheme: "xri",
allowPort: function() {
return false; // only called for blacklisted ports, should respect
},
_newHttpChannel: function(aURI)
{
var HXRI = PROXY_URI + aURI.spec;
var ioService = Components.classesByID[kIOSERVICE_CID_STR].getService();
ioService = ioService.QueryInterface(nsIIOService);
var channel = ioService.newChannel(HXRI, null, null);
return channel;
},
newChannel: function(aURI)
{
// leave alone if path is not empty or just a single slash or query exists
dump("path='" + aURI.path + "'\n");
dump("query='" + aURI.query + "'\n");
dump("spec='" + aURI.spec + "'\n");
var slashPos = aURI.spec.indexOf('/', 'xri://'.length);
var qmarkPos = aURI.spec.indexOf('?');
dump("slashPos='" + slashPos + "'\n");
dump("qmarkPos='" + qmarkPos + "'\n");
if ((slashPos > 0 && slashPos < aURI.spec.length - 1) || qmarkPos > -1) {
return this._newHttpChannel(aURI);
}
var explorer = new XRIChannel(aURI);
return explorer;
},
newURI: function(spec, originCharset, baseURI)
{
var newSpec = spec;
if (baseURI != null) {
// standard-url (nsIURL) does not work with @-GCS
var baseURL = Components.classes[CID_URL].createInstance(nsIURL);
baseURL.spec = baseURI.spec;
newSpec = baseURL.resolve(spec);
}
var uri = Components.classes[CID_URI].createInstance(nsIURI);
uri.spec = newSpec;
return uri;
},
QueryInterface: function(aIID)
{
if (!aIID.equals(nsIProtocolHandler) &&
!aIID.equals(nsISupports))
throw Components.results.NS_ERROR_NO_INTERFACE;
return this;
}
};
/***********************************************************
class factory
This object is a member of the global-scope Components.classes.
It is keyed off of the contract ID. Eg:
myXriProtocolHandler = Components.classes["@dietrich.ganx4.com/helloworld;1"].
createInstance(Components.interfaces.nsIXriProtocolHandler);
***********************************************************/
var XriProtocolHandlerFactory = {
createInstance: function (aOuter, aIID)
{
if (aOuter != null)
throw Components.results.NS_ERROR_NO_AGGREGATION;
return (new XriProtocolHandler()).QueryInterface(aIID);
}
};
/***********************************************************
module definition (xpcom registration)
***********************************************************/
var XriProtocolHandlerModule = {
_firstTime: true,
registerSelf: function(aCompMgr, aFileSpec, aLocation, aType)
{
if (this._firstTime) {
this._firstTime = false;
throw Components.results.NS_ERROR_FACTORY_REGISTER_AGAIN;
}
aCompMgr = aCompMgr.
QueryInterface(Components.interfaces.nsIComponentRegistrar);
aCompMgr.registerFactoryLocation(CLASS_ID, CLASS_NAME,
CONTRACT_ID, aFileSpec, aLocation, aType);
},
unregisterSelf: function(aCompMgr, aLocation, aType)
{
aCompMgr = aCompMgr.
QueryInterface(Components.interfaces.nsIComponentRegistrar);
aCompMgr.unregisterFactoryLocation(CLASS_ID, aLocation);
},
getClassObject: function(aCompMgr, aCID, aIID)
{
if (!aIID.equals(Components.interfaces.nsIFactory))
throw Components.results.NS_ERROR_NOT_IMPLEMENTED;
if (aCID.equals(CLASS_ID))
return XriProtocolHandlerFactory;
throw Components.results.NS_ERROR_NO_INTERFACE;
},
canUnload: function(aCompMgr) { return true; }
};
/***********************************************************
module initialization
When the application registers the component, this function
is called.
***********************************************************/
function NSGetModule(aCompMgr, aFileSpec) { return XriProtocolHandlerModule; }
diff --git a/src/install.rdf b/src/install.rdf index a482755..507420c 100755 --- a/src/install.rdf +++ b/src/install.rdf @@ -1,40 +1,40 @@ <?xml version="1.0"?>
<RDF xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:em="http://www.mozilla.org/2004/em-rdf#">
<Description about="urn:mozilla:install-manifest">
<em:id>foxri@foxri.net</em:id>
- <em:version>1.1.1</em:version>
+ <em:version>1.1.2</em:version>
<em:type>2</em:type>
<!-- Target Application this extension can install into,
with minimum and maximum supported versions. -->
<em:targetApplication>
<Description>
<em:id>{ec8030f7-c20a-464f-9b0e-13a3a9e97384}</em:id>
<em:minVersion>1.0</em:minVersion>
- <em:maxVersion>1.5.0.*</em:maxVersion>
+ <em:maxVersion>2.0.*</em:maxVersion>
</Description>
</em:targetApplication>
<em:targetApplication>
<Description>
<em:id>{a463f10c-3994-11da-9945-000d60ca027b}</em:id>
<em:minVersion>0.5</em:minVersion>
<em:maxVersion>0.8</em:maxVersion>
</Description>
</em:targetApplication>
<!-- Front End MetaData -->
<em:name>FoXRI</em:name>
<em:description>XRI Extension</em:description>
<em:creator>William Tan</em:creator>
<em:homepageURL>http://dready.org/projects/foxri</em:homepageURL>
<!--
<em:updateURL>http://dready.org/projects/foxri/update.rdf</em:updateURL>
-->
</Description>
</RDF>
|