tweaked web_send.js etc.

web_send.js

/*
 * Copyright 2007-2009 Tyler Close under the terms of the MIT X license found
 * at http://www.opensource.org/licenses/mit-license.html
 *
 * web_send.js version: 2009-06-06
 *
 * This library doesn't actually pass the ADsafe verifier, but rather is
 * designed to provide a controlled interface to the network, that can be
 * loaded as an ADsafe library. Clients of this library have permission to send
 * requests to the window target, and any target returned in a request
 * response.  ADsafe verified clients *cannot* construct a remote reference
 * from whole cloth by providing a URL. In this way, a server can control the
 * client's network access by controlling what remote references are made
 * available to the client.
 *
 * In addition to messaging, the client is also permitted to read/write the
 * window title and navigate the window to any received remote target.
 */
/*global ADSAFE, window, ActiveXObject, XMLHttpRequest */
/*jslint white: false, nomen: false, regexp: false, bitwise: true, eqeqeq: true,
         immed: true, newcap: true, plusplus: true, strict: true, undef: true */
//"use strict";
ADSAFE.lib('web', function (lib) {

    /**
     * Does an object define a given key?
     */
    function includes(map, key) {
        return map && Object.hasOwnProperty.call(map, key);
    }

    /**
     * secret slot to extract the URL from a remote reference
     */
    var unsealedURLref = null;

    function unsealURLref(p) {
        unsealedURLref = null;
        if ('function' === typeof p) { p(); }
        var r = unsealedURLref;
        unsealedURLref = null;
        return r;
    }

    /**
     * value returned on a 404 server response
     */
    var notYetPumpkin = lib.Q.reject({
        'class': [ 'org.ref_send.promise.Failure', 'NaO' ],
        status: 404,
        phrase: 'Not Found'
    });

    /**
     * advance declaration of send() function for JSLint
     */
    var send = undefined;

    /**
     * Constructs a remote reference.
     * @param href  absolute URLref for target resource
     * @param props optional properties of the returned promise
     */
    function sealURLref(href, props) {
        if ('string' !== typeof href) { throw new Error(); }

        var cache = null;
        var resolved = false;
        function proxy(op, arg1, arg2, arg3) {
            if (undefined === op) {
                unsealedURLref = href;
                return resolved ? cache() : proxy;
            }
            if ('WHEN' === op) {
                if (!cache) {
                    var pr = lib.Q.defer();
                    cache = pr.promise;
                    var a = 0;
                    var b = 1 * 1000;
                    var retry = function (x) {
                        if (notYetPumpkin === x) {
                            // poll for the resolved value of the promise
                            ADSAFE.later(function () {
                                send(proxy, href, 'GET', retry);
                            }, b);
                            var c = Math.min(a + b, 60 * 60 * 1000);
                            a = b;
                            b = c;
                        } else {
                            // if it resolved to itself, it's a remote
                            // reference, not a promise
                            pr.resolve((href===unsealURLref(x))?lib.Q.ref(x):x);
                            resolved = true;
                        }
                    };
                    send(proxy, href, 'GET', retry);
                }
                // process when blocks in the same order as other requests
                send(cache, href, 'WHEN', null, null, [ arg1, arg2 ]);
            } else {
                send(proxy, href, op, function (r) {
                    if (notYetPumpkin === r) {
                        // resend on the resolved value of the promise
                        proxy('WHEN', function (x) {
                            (('function' === typeof x) ? x : lib.Q.ref(x))(
                                op, arg1, arg2, arg3);
                        }, function (reason) {
                            if (arg1) { arg1(lib.Q.reject(reason)); }
                        });
                    } else {
                        if (arg1) { arg1(r); }
                    }
                }, arg2, arg3);
            }
        }
        if (props) {
            for (var k in props) { if (includes(props, k)) {
                if ('@' !== k) {
                    proxy[k] = props[k];
                }
            } }
        }
        return proxy;
    }

    /**
     * Produces a relative URL reference.
     * @param base  absolute base URLref
     * @param href  absolute target URLref
     */
    function relateURI(base, href) {
        var baseOP  = /^([a-zA-Z][\w\-\.\+]*:\/\/[^\/]*\/)([^\?#]*)/.exec(base);
        var hrefOPR = /^([a-zA-Z][\w\-\.\+]*:\/\/[^\/]*\/)([^\?#]*)(.*)$/.
                                                                     exec(href);
        if (!baseOP || !hrefOPR || baseOP[1] !== hrefOPR[1]) { return href; }

        // determine the common parent folder
        var basePath = baseOP[2].split('/');
        var hrefPath = hrefOPR[2].split('/');
        var maxMatch = Math.min(basePath.length, hrefPath.length) - 1;
        var i = 0;
        while (i !== maxMatch && basePath[i] === hrefPath[i]) { i += 1; }

        // wind up to the common parent folder
        var cd = '';
        for (var n = basePath.length - i - 1; 0 !== n; n -= 1) { cd += '../'; }
        if ('' === cd) {
            cd = './';
        }
        return cd + hrefPath.slice(i).join('/') + hrefOPR[3];
    }

    /**
     * Produce the JSON text for a JSON value.
     * @param base  absolute base URLref
     * @param arg   JSON value to serialize
     */
    function serialize(base, arg) {
        if (null === arg || 'object' !== typeof arg) {
            arg = { '=' : arg };
        }
        return JSON.stringify(arg, function (key, value) {
            if ('function' === typeof value) {
                unsealedURLref = null;
                value = value();
                var href = unsealedURLref;
                unsealedURLref = null;

                if (null !== href) {
                    var r = {};
                    for (var k in value) { if (includes(value, k)) {
                        if ('@' !== k) {
                            r[k] = value[k];
                        }
                    } }
                    r['@'] = relateURI(base, href);
                    return r;
                }

                if ('function' === typeof value && includes(value, 'reason')) {
                    return {
                        '!' : value('WHEN', null, function (e) { return e; })
                    };
                }
            }
            if ('number' === typeof value && !isFinite(value)) {
                return { '!' : { 'class': [ 'NaN' ] } };
            }
            if (includes(value, '@')) { throw new Error('forged reference'); }
            return value;
        }, ' ');
    }

    /**
     * Resolves a relative URL reference.
     * @param base  absolute base URL
     * @param href  relative URL to resolve
     */
    function resolveURI(base, href) {
        if (/^[a-zA-Z][\w\-\.\+]*:/.test(href)) { return href; }

        base = /^[^#]*/.exec(base)[0];  // never include base fragment
        if ('' === href) { return base; }
        if (/^#/.test(href)) { return base + href; }
        if (/^\/\//.test(href)) {
            return (/^[a-zA-Z][\w\-\.\+]*:/).exec(base)[0] + href;
        }
        if (/^\//.test(href)) {
            return (/^[a-zA-Z][\w\-\.\+]*:\/\/[^\/]*/).exec(base)[0] + href;
        }

        base = /^[^\?]*/.exec(base)[0]; // drop base query
        if (/^\?/.test(href)) { return base + href; }

        // unwind relative path operators
        base = base.substring(0, base.lastIndexOf('/') + 1);
        var baseOP = /^([a-zA-Z][\w\-\.\+]*:\/\/[^\/]*\/)(.*)$/.exec(base);
        var origin = baseOP[1];
        var path = baseOP[2];
        while (true) {
            if (/^\.\.\//.test(href)) {
                path = path.substring(0, path.lastIndexOf('/',path.length-2)+1);
                href = href.substring('../'.length);
            } else if (/^\.\//.test(href)) {
                href = href.substring('./'.length);
            } else {
                break;
            }
        }
        if (/^\.\.(#|\?|$)/.test(href)) {
            path = path.substring(0, path.lastIndexOf('/', path.length-2) + 1);
            href = href.substring('..'.length);
        }
        if (/^\.(#|\?|$)/.test(href)) {
            href = href.substring('.'.length);
        }
        return origin + path + href;
    }

    /**
     * Deserializes the return value from an HTTP response.
     * @param base  base URL for request
     * @param http  HTTP response
     */
    function deserialize(base, http) {
        switch (http.status) {
        case 200:
        case 201:
        case 202:
        case 203:
            return JSON.parse(http.responseText, function (key, value) {
                if (includes(value, '!')) { return lib.Q.reject(value['!']); }
                if (includes(value, '@')) {
                    return sealURLref(resolveURI(base, value['@']), value);
                }
                if (includes(value, '=')) { return value['=']; }
                return value;
            });
        case 204:
        case 205:
            return {};
        case 404:
            return notYetPumpkin;
        default:
            return lib.Q.reject({
                'class': [ 'org.ref_send.promise.Failure', 'NaO' ],
                status: http.status,
                phrase: http.statusText
            });
        }
    }

    /**
     * Constructs a Request-URI with options.
     * @param href  target URLref
     * @param q     optional client-specified query
     * @param x     optional session key
     * @param w     optional message window number
     */
    function makeRequestURI(href, q, x, w) {
        var requestQuery = '';
        if (undefined !== q && null !== q) {
            requestQuery = '?q=' + encodeURIComponent(String(q));
        }
        if (x) {
            requestQuery += ('' === requestQuery) ? '?' : '&';
            requestQuery += 'x=' + encodeURIComponent(String(x));
            requestQuery += '&w=' + encodeURIComponent(String(w));
        }
        var pqf = /([^\?#]*)([^#]*)(.*)/.exec(href);
        if (pqf[2]) {
            requestQuery += ('' === requestQuery) ? '?' : '&';
            requestQuery += pqf[2].substring(1);
        }
        if (pqf[3]) {
            var args = pqf[3].substring(1).split('&');
            for (var i = 0; i !== args.length; i += 1) {
                if (/^=/.test(args[i])) {
                    var id = args[i].substring(1);
                    requestQuery += '#' + id;
                    if (i + 1 !== args.length) {
                        requestQuery += (id ? '&' : '') +
                                        args.slice(i + 1).join('&');
                    }
                    break;
                }
                requestQuery += ('' === requestQuery) ? '?' : '&';
                requestQuery += args[i];
            }
        }
        return pqf[1] + requestQuery;
    }

    /**
     * Constructs a pending request queue.
     */
    function makeSession() {
        var x = null;               // session id
        var w = 0;                  // number of received responses
        var pending = [];           // pending requests
        var initialized = false;    // session initialization request queued?
        var connection = null;      // current connection

        function popRequest(msg) {
            w += 1;
            if (msg !== pending.shift()) { throw new Error(); }
            if (0 === pending.length) {
                connection = null;
            } else {
                ADSAFE.later(connection);
            }
        }

        function makeConnection(timeout) {
            if (undefined === timeout) {
                timeout = 15 * 1000;
            }

            var http;
            if (this.XMLHttpRequest) {
                http = new XMLHttpRequest();
            } else {
                http = new ActiveXObject('Microsoft.XMLHTTP');
            }
            var heartbeat = (new Date()).getTime();
            var m = function () {
                if (m !== connection) { return; }

                var msg = pending[0];
                if ('WHEN' === msg.op) {
                    popRequest(msg);
                    msg.target('WHEN', msg.argv[0], msg.argv[1]);
                    return;
                }

                var requestURI = makeRequestURI(msg.href, msg.q,
                                                msg.idempotent ? null : x, w);
                try {
                    http.open(msg.op, /^[^#]*/.exec(requestURI)[0], true);
                } catch (reason) {
                    popRequest(msg);
                    if (msg.resolve) { msg.resolve(lib.Q.reject(reason)); }
                    return;
                }
                http.onreadystatechange = function () {
                    if (3 === http.readyState || 4 === http.readyState) {
                        heartbeat = (new Date()).getTime();
                    }
                    if (m !== connection) { return; }

                    if (4 !== http.readyState) { return; }
                    try {
                        if (http.status < 200 || http.status >= 500) { return; }
                    } catch (e) { return; }

                    popRequest(msg);
                    if (msg.resolve) {
                        msg.resolve(deserialize(requestURI, http));
                    }
                };
                if (undefined === msg.argv) {
                    http.send(null);
                } else {
                    try {
                        /*
                         * Use Content-Type "text/plain" so that a POST request
                         * remains a 'simple method' in the rules for
                         * cross-domain XHR.
                         */
                        http.setRequestHeader('Content-Type', 'text/plain');
                    } catch (e) {}
                    http.send(serialize(requestURI, msg.argv));
                }
            };
            if (timeout) { (function () {
                var watcher = function () {
                    if (connection !== m) { return; }

                    var delta = ((new Date()).getTime()) - heartbeat;
                    if (delta >= timeout) {
                        if (x || pending[0].idempotent) {
                            connection = makeConnection(
                                Math.min(10 * timeout, 60 * 60 * 1000));
                            ADSAFE.later(connection);
                            try { http.abort(); } catch (e) {}
                        }
                    } else {
                        ADSAFE.later(watcher, timeout - delta);
                    }
                };
                ADSAFE.later(watcher, timeout);
            }()); }
            return m;
        }

        return function (target, href, op, resolve, q, argv) {
            var idempotent = 'GET'     === op || 'HEAD'   === op ||
                             'PUT'     === op || 'DELETE' === op ||
                             'OPTIONS' === op || 'TRACE'  === op ||
                             'WHEN'    === op;
            if (!idempotent && !initialized) {
                pending.push({
                    idempotent: true,
                    href: resolveURI(href, '?q=fresh&s=sessions'),
                    op: 'GET',
                    resolve: function (value) {
                        if (includes(value, 'sessionKey')) {
                            x = value.sessionKey;
                        }
                    }
                });
                initialized = true;
            }
            pending.push({
                idempotent: idempotent,
                target: target,
                href: href,
                op: op,
                resolve: resolve,
                q: q,
                argv: argv
            });
            if (!connection) {
                connection = makeConnection();
                ADSAFE.later(connection);
            }
        };
    }

    /**
     * Enqueues an HTTP request.
     * @param target    target reference
     * @param href      target URLref
     * @param op        HTTP verb
     * @param resolve   response resolver
     * @param q         query string argument
     * @param argv      JSON value for request body
     */
    send = (function () {
        var sessions = { /* origin => session */ };
        return function (target, href, op, resolve, q, argv) {
            var origin = resolveURI(href, '/');
            var session = ADSAFE.get(sessions, origin);
            if (!session) {
                session = makeSession();
                ADSAFE.set(sessions, origin, session);
            }
            return session(target, href, op, resolve, q, argv);
        };
    }());

    function allowedNavigationScheme(href) {
        return (/^https:/i).test(href) || (/^http:/i).test(href);
    }

    return {

        /**
         * Gets a remote reference for the window's current location.
         */
        getLocation: function () { return sealURLref(window.location.href); },

        /**
         * Navigate the window.
         * @param target    remote reference for new location
         * @return <code>true</code> if navigation successful,
         *         else <code>false</code>
         */
        navigate: function (target) {
            var href = unsealURLref(target);
            if (null === href) { return false; }
            if (!allowedNavigationScheme(href)) { return false; }

            window.location.assign(href);
            return true;
        },

        /**
         * Sets the 'href' attribute.
         * @param element   element to modify
         * @param target    remote reference
         * @return the element, or the ':rest' of the bunch if not modified
         */
        href: function (element, target) {
            if (element.count()) {
                if (null === target) {
                    element.___nodes___[0].removeAttribute('href');
                } else {
                    var href = unsealURLref(target);
                    if (null !== href && allowedNavigationScheme(href)) {
                        var _node = element.___nodes___[0];
                        if ('A' === _node.tagName.toUpperCase()) {
                            _node.setAttribute('href', href);
                        } else {
                            element = element.q(':rest');
                        }
                    } else {
                        element = element.q(':rest');
                    }
                }
            }
            return element;
        },

        /**
         * Sets the 'src' attribute.
         * @param element   element to modify
         * @param target    remote reference
         * @return the element, or the ':rest' of the bunch if not modified
         */
        src: function (element, target) {
            if (element.count()) {
                if (null === target) {
                    element.___nodes___[0].removeAttribute('src');
                } else {
                    var src = unsealURLref(target);
                    if (null !== src && allowedNavigationScheme(src)) {
                        var _node = element.___nodes___[0];
                        switch (_node.tagName.toUpperCase()) {
                        case 'IMG':
                        case 'INPUT':
                            _node.setAttribute('src', makeRequestURI(src));
                            break;
                        default:
                            element = element.q(':rest');
                        }
                    } else {
                        element = element.q(':rest');
                    }
                }
            }
            return element;
        },

        /**
         * Constructs a remote reference from a URLref held in a password field.
         * @param field bunch containing a single password field
         */
        fetch: function (field) {
            var _nodes = field.___nodes___;
            if (1 !== _nodes.length) { return; }
            var _node = _nodes[0];
            if (!(/^INPUT$/i).test(_node.tagName)) { return; }
            if ('password' !== _node.type) { return; }
            var href = _node.value;
            if (!/^[a-zA-Z][\w\-\.\+]*:/.test(href)) { return null; }
            return sealURLref(href);
        },

        /**
         * Gets the document title.
         */
        getTitle: function () { return window.document.title; },

        /**
         * Sets the document title.
         * @param text  new title text
         */
        title: function (text) { window.document.title = text; },

        // Non-ADsafe API

        /**
         * Constructs a remote reference.
         * @param base  optional remote reference for base URLref
         * @param href  URLref to wrap
         * @param args  optional query argument map
         */
        _ref: function (base, href, args) {
            var url = resolveURI(unsealURLref(base), href);
            if (undefined !== args && null !== args) {
                var query = '?';
                if ('object' === typeof args) {
                    for (var k in args) { if (includes(args, k)) {
                        if ('?' !== query) {
                            query += '&';
                        }
                        query += encodeURIComponent(String(k)) + '=' +
                                 encodeURIComponent(String(ADSAFE.get(args,k)));
                    } }
                } else {
                    query += args;
                }
                url = resolveURI(url, query);
            }
            return sealURLref(url);
        },

        /**
         * Extracts the URLref contained within a remote reference.
         * @param arg       remote reference to extract URLref from
         * @param target    optional remote reference for base URL
         * @return the URLref, or <code>null</code> if not a remote reference
         */
        _url: function (arg, target) {
            var href = unsealURLref(arg);
            if (null === href || !target) { return href; }
            var base = unsealURLref(target);
            if (null === base) { return href; }
            return relateURI(base, href);
        }
    };
});