You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1364 lines
38 KiB
1364 lines
38 KiB
/** |
|
* HTTP client-side implementation that uses forge.net sockets. |
|
* |
|
* @author Dave Longley |
|
* |
|
* Copyright (c) 2010-2014 Digital Bazaar, Inc. All rights reserved. |
|
*/ |
|
var forge = require('./forge'); |
|
require('./debug'); |
|
require('./tls'); |
|
require('./util'); |
|
|
|
// define http namespace |
|
var http = module.exports = forge.http = forge.http || {}; |
|
|
|
// logging category |
|
var cat = 'forge.http'; |
|
|
|
// add array of clients to debug storage |
|
if(forge.debug) { |
|
forge.debug.set('forge.http', 'clients', []); |
|
} |
|
|
|
// normalizes an http header field name |
|
var _normalize = function(name) { |
|
return name.toLowerCase().replace(/(^.)|(-.)/g, |
|
function(a) {return a.toUpperCase();}); |
|
}; |
|
|
|
/** |
|
* Gets the local storage ID for the given client. |
|
* |
|
* @param client the client to get the local storage ID for. |
|
* |
|
* @return the local storage ID to use. |
|
*/ |
|
var _getStorageId = function(client) { |
|
// TODO: include browser in ID to avoid sharing cookies between |
|
// browsers (if this is undesirable) |
|
// navigator.userAgent |
|
return 'forge.http.' + |
|
client.url.scheme + '.' + |
|
client.url.host + '.' + |
|
client.url.port; |
|
}; |
|
|
|
/** |
|
* Loads persistent cookies from disk for the given client. |
|
* |
|
* @param client the client. |
|
*/ |
|
var _loadCookies = function(client) { |
|
if(client.persistCookies) { |
|
try { |
|
var cookies = forge.util.getItem( |
|
client.socketPool.flashApi, |
|
_getStorageId(client), 'cookies'); |
|
client.cookies = cookies || {}; |
|
} catch(ex) { |
|
// no flash storage available, just silently fail |
|
// TODO: i assume we want this logged somewhere or |
|
// should it actually generate an error |
|
//forge.log.error(cat, ex); |
|
} |
|
} |
|
}; |
|
|
|
/** |
|
* Saves persistent cookies on disk for the given client. |
|
* |
|
* @param client the client. |
|
*/ |
|
var _saveCookies = function(client) { |
|
if(client.persistCookies) { |
|
try { |
|
forge.util.setItem( |
|
client.socketPool.flashApi, |
|
_getStorageId(client), 'cookies', client.cookies); |
|
} catch(ex) { |
|
// no flash storage available, just silently fail |
|
// TODO: i assume we want this logged somewhere or |
|
// should it actually generate an error |
|
//forge.log.error(cat, ex); |
|
} |
|
} |
|
|
|
// FIXME: remove me |
|
_loadCookies(client); |
|
}; |
|
|
|
/** |
|
* Clears persistent cookies on disk for the given client. |
|
* |
|
* @param client the client. |
|
*/ |
|
var _clearCookies = function(client) { |
|
if(client.persistCookies) { |
|
try { |
|
// only thing stored is 'cookies', so clear whole storage |
|
forge.util.clearItems( |
|
client.socketPool.flashApi, |
|
_getStorageId(client)); |
|
} catch(ex) { |
|
// no flash storage available, just silently fail |
|
// TODO: i assume we want this logged somewhere or |
|
// should it actually generate an error |
|
//forge.log.error(cat, ex); |
|
} |
|
} |
|
}; |
|
|
|
/** |
|
* Connects and sends a request. |
|
* |
|
* @param client the http client. |
|
* @param socket the socket to use. |
|
*/ |
|
var _doRequest = function(client, socket) { |
|
if(socket.isConnected()) { |
|
// already connected |
|
socket.options.request.connectTime = +new Date(); |
|
socket.connected({ |
|
type: 'connect', |
|
id: socket.id |
|
}); |
|
} else { |
|
// connect |
|
socket.options.request.connectTime = +new Date(); |
|
socket.connect({ |
|
host: client.url.host, |
|
port: client.url.port, |
|
policyPort: client.policyPort, |
|
policyUrl: client.policyUrl |
|
}); |
|
} |
|
}; |
|
|
|
/** |
|
* Handles the next request or marks a socket as idle. |
|
* |
|
* @param client the http client. |
|
* @param socket the socket. |
|
*/ |
|
var _handleNextRequest = function(client, socket) { |
|
// clear buffer |
|
socket.buffer.clear(); |
|
|
|
// get pending request |
|
var pending = null; |
|
while(pending === null && client.requests.length > 0) { |
|
pending = client.requests.shift(); |
|
if(pending.request.aborted) { |
|
pending = null; |
|
} |
|
} |
|
|
|
// mark socket idle if no pending requests |
|
if(pending === null) { |
|
if(socket.options !== null) { |
|
socket.options = null; |
|
} |
|
client.idle.push(socket); |
|
} else { |
|
// handle pending request, allow 1 retry |
|
socket.retries = 1; |
|
socket.options = pending; |
|
_doRequest(client, socket); |
|
} |
|
}; |
|
|
|
/** |
|
* Sets up a socket for use with an http client. |
|
* |
|
* @param client the parent http client. |
|
* @param socket the socket to set up. |
|
* @param tlsOptions if the socket must use TLS, the TLS options. |
|
*/ |
|
var _initSocket = function(client, socket, tlsOptions) { |
|
// no socket options yet |
|
socket.options = null; |
|
|
|
// set up handlers |
|
socket.connected = function(e) { |
|
// socket primed by caching TLS session, handle next request |
|
if(socket.options === null) { |
|
_handleNextRequest(client, socket); |
|
} else { |
|
// socket in use |
|
var request = socket.options.request; |
|
request.connectTime = +new Date() - request.connectTime; |
|
e.socket = socket; |
|
socket.options.connected(e); |
|
if(request.aborted) { |
|
socket.close(); |
|
} else { |
|
var out = request.toString(); |
|
if(request.body) { |
|
out += request.body; |
|
} |
|
request.time = +new Date(); |
|
socket.send(out); |
|
request.time = +new Date() - request.time; |
|
socket.options.response.time = +new Date(); |
|
socket.sending = true; |
|
} |
|
} |
|
}; |
|
socket.closed = function(e) { |
|
if(socket.sending) { |
|
socket.sending = false; |
|
if(socket.retries > 0) { |
|
--socket.retries; |
|
_doRequest(client, socket); |
|
} else { |
|
// error, closed during send |
|
socket.error({ |
|
id: socket.id, |
|
type: 'ioError', |
|
message: 'Connection closed during send. Broken pipe.', |
|
bytesAvailable: 0 |
|
}); |
|
} |
|
} else { |
|
// handle unspecified content-length transfer |
|
var response = socket.options.response; |
|
if(response.readBodyUntilClose) { |
|
response.time = +new Date() - response.time; |
|
response.bodyReceived = true; |
|
socket.options.bodyReady({ |
|
request: socket.options.request, |
|
response: response, |
|
socket: socket |
|
}); |
|
} |
|
socket.options.closed(e); |
|
_handleNextRequest(client, socket); |
|
} |
|
}; |
|
socket.data = function(e) { |
|
socket.sending = false; |
|
var request = socket.options.request; |
|
if(request.aborted) { |
|
socket.close(); |
|
} else { |
|
// receive all bytes available |
|
var response = socket.options.response; |
|
var bytes = socket.receive(e.bytesAvailable); |
|
if(bytes !== null) { |
|
// receive header and then body |
|
socket.buffer.putBytes(bytes); |
|
if(!response.headerReceived) { |
|
response.readHeader(socket.buffer); |
|
if(response.headerReceived) { |
|
socket.options.headerReady({ |
|
request: socket.options.request, |
|
response: response, |
|
socket: socket |
|
}); |
|
} |
|
} |
|
if(response.headerReceived && !response.bodyReceived) { |
|
response.readBody(socket.buffer); |
|
} |
|
if(response.bodyReceived) { |
|
socket.options.bodyReady({ |
|
request: socket.options.request, |
|
response: response, |
|
socket: socket |
|
}); |
|
// close connection if requested or by default on http/1.0 |
|
var value = response.getField('Connection') || ''; |
|
if(value.indexOf('close') != -1 || |
|
(response.version === 'HTTP/1.0' && |
|
response.getField('Keep-Alive') === null)) { |
|
socket.close(); |
|
} else { |
|
_handleNextRequest(client, socket); |
|
} |
|
} |
|
} |
|
} |
|
}; |
|
socket.error = function(e) { |
|
// do error callback, include request |
|
socket.options.error({ |
|
type: e.type, |
|
message: e.message, |
|
request: socket.options.request, |
|
response: socket.options.response, |
|
socket: socket |
|
}); |
|
socket.close(); |
|
}; |
|
|
|
// wrap socket for TLS |
|
if(tlsOptions) { |
|
socket = forge.tls.wrapSocket({ |
|
sessionId: null, |
|
sessionCache: {}, |
|
caStore: tlsOptions.caStore, |
|
cipherSuites: tlsOptions.cipherSuites, |
|
socket: socket, |
|
virtualHost: tlsOptions.virtualHost, |
|
verify: tlsOptions.verify, |
|
getCertificate: tlsOptions.getCertificate, |
|
getPrivateKey: tlsOptions.getPrivateKey, |
|
getSignature: tlsOptions.getSignature, |
|
deflate: tlsOptions.deflate || null, |
|
inflate: tlsOptions.inflate || null |
|
}); |
|
|
|
socket.options = null; |
|
socket.buffer = forge.util.createBuffer(); |
|
client.sockets.push(socket); |
|
if(tlsOptions.prime) { |
|
// prime socket by connecting and caching TLS session, will do |
|
// next request from there |
|
socket.connect({ |
|
host: client.url.host, |
|
port: client.url.port, |
|
policyPort: client.policyPort, |
|
policyUrl: client.policyUrl |
|
}); |
|
} else { |
|
// do not prime socket, just add as idle |
|
client.idle.push(socket); |
|
} |
|
} else { |
|
// no need to prime non-TLS sockets |
|
socket.buffer = forge.util.createBuffer(); |
|
client.sockets.push(socket); |
|
client.idle.push(socket); |
|
} |
|
}; |
|
|
|
/** |
|
* Checks to see if the given cookie has expired. If the cookie's max-age |
|
* plus its created time is less than the time now, it has expired, unless |
|
* its max-age is set to -1 which indicates it will never expire. |
|
* |
|
* @param cookie the cookie to check. |
|
* |
|
* @return true if it has expired, false if not. |
|
*/ |
|
var _hasCookieExpired = function(cookie) { |
|
var rval = false; |
|
|
|
if(cookie.maxAge !== -1) { |
|
var now = _getUtcTime(new Date()); |
|
var expires = cookie.created + cookie.maxAge; |
|
if(expires <= now) { |
|
rval = true; |
|
} |
|
} |
|
|
|
return rval; |
|
}; |
|
|
|
/** |
|
* Adds cookies in the given client to the given request. |
|
* |
|
* @param client the client. |
|
* @param request the request. |
|
*/ |
|
var _writeCookies = function(client, request) { |
|
var expired = []; |
|
var url = client.url; |
|
var cookies = client.cookies; |
|
for(var name in cookies) { |
|
// get cookie paths |
|
var paths = cookies[name]; |
|
for(var p in paths) { |
|
var cookie = paths[p]; |
|
if(_hasCookieExpired(cookie)) { |
|
// store for clean up |
|
expired.push(cookie); |
|
} else if(request.path.indexOf(cookie.path) === 0) { |
|
// path or path's ancestor must match cookie.path |
|
request.addCookie(cookie); |
|
} |
|
} |
|
} |
|
|
|
// clean up expired cookies |
|
for(var i = 0; i < expired.length; ++i) { |
|
var cookie = expired[i]; |
|
client.removeCookie(cookie.name, cookie.path); |
|
} |
|
}; |
|
|
|
/** |
|
* Gets cookies from the given response and adds the to the given client. |
|
* |
|
* @param client the client. |
|
* @param response the response. |
|
*/ |
|
var _readCookies = function(client, response) { |
|
var cookies = response.getCookies(); |
|
for(var i = 0; i < cookies.length; ++i) { |
|
try { |
|
client.setCookie(cookies[i]); |
|
} catch(ex) { |
|
// ignore failure to add other-domain, etc. cookies |
|
} |
|
} |
|
}; |
|
|
|
/** |
|
* Creates an http client that uses forge.net sockets as a backend and |
|
* forge.tls for security. |
|
* |
|
* @param options: |
|
* url: the url to connect to (scheme://host:port). |
|
* socketPool: the flash socket pool to use. |
|
* policyPort: the flash policy port to use (if other than the |
|
* socket pool default), use 0 for flash default. |
|
* policyUrl: the flash policy file URL to use (if provided will |
|
* be used instead of a policy port). |
|
* connections: number of connections to use to handle requests. |
|
* caCerts: an array of certificates to trust for TLS, certs may |
|
* be PEM-formatted or cert objects produced via forge.pki. |
|
* cipherSuites: an optional array of cipher suites to use, |
|
* see forge.tls.CipherSuites. |
|
* virtualHost: the virtual server name to use in a TLS SNI |
|
* extension, if not provided the url host will be used. |
|
* verify: a custom TLS certificate verify callback to use. |
|
* getCertificate: an optional callback used to get a client-side |
|
* certificate (see forge.tls for details). |
|
* getPrivateKey: an optional callback used to get a client-side |
|
* private key (see forge.tls for details). |
|
* getSignature: an optional callback used to get a client-side |
|
* signature (see forge.tls for details). |
|
* persistCookies: true to use persistent cookies via flash local |
|
* storage, false to only keep cookies in javascript. |
|
* primeTlsSockets: true to immediately connect TLS sockets on |
|
* their creation so that they will cache TLS sessions for reuse. |
|
* |
|
* @return the client. |
|
*/ |
|
http.createClient = function(options) { |
|
// create CA store to share with all TLS connections |
|
var caStore = null; |
|
if(options.caCerts) { |
|
caStore = forge.pki.createCaStore(options.caCerts); |
|
} |
|
|
|
// get scheme, host, and port from url |
|
options.url = (options.url || |
|
window.location.protocol + '//' + window.location.host); |
|
var url = http.parseUrl(options.url); |
|
if(!url) { |
|
var error = new Error('Invalid url.'); |
|
error.details = {url: options.url}; |
|
throw error; |
|
} |
|
|
|
// default to 1 connection |
|
options.connections = options.connections || 1; |
|
|
|
// create client |
|
var sp = options.socketPool; |
|
var client = { |
|
// url |
|
url: url, |
|
// socket pool |
|
socketPool: sp, |
|
// the policy port to use |
|
policyPort: options.policyPort, |
|
// policy url to use |
|
policyUrl: options.policyUrl, |
|
// queue of requests to service |
|
requests: [], |
|
// all sockets |
|
sockets: [], |
|
// idle sockets |
|
idle: [], |
|
// whether or not the connections are secure |
|
secure: (url.scheme === 'https'), |
|
// cookie jar (key'd off of name and then path, there is only 1 domain |
|
// and one setting for secure per client so name+path is unique) |
|
cookies: {}, |
|
// default to flash storage of cookies |
|
persistCookies: (typeof(options.persistCookies) === 'undefined') ? |
|
true : options.persistCookies |
|
}; |
|
|
|
// add client to debug storage |
|
if(forge.debug) { |
|
forge.debug.get('forge.http', 'clients').push(client); |
|
} |
|
|
|
// load cookies from disk |
|
_loadCookies(client); |
|
|
|
/** |
|
* A default certificate verify function that checks a certificate common |
|
* name against the client's URL host. |
|
* |
|
* @param c the TLS connection. |
|
* @param verified true if cert is verified, otherwise alert number. |
|
* @param depth the chain depth. |
|
* @param certs the cert chain. |
|
* |
|
* @return true if verified and the common name matches the host, error |
|
* otherwise. |
|
*/ |
|
var _defaultCertificateVerify = function(c, verified, depth, certs) { |
|
if(depth === 0 && verified === true) { |
|
// compare common name to url host |
|
var cn = certs[depth].subject.getField('CN'); |
|
if(cn === null || client.url.host !== cn.value) { |
|
verified = { |
|
message: 'Certificate common name does not match url host.' |
|
}; |
|
} |
|
} |
|
return verified; |
|
}; |
|
|
|
// determine if TLS is used |
|
var tlsOptions = null; |
|
if(client.secure) { |
|
tlsOptions = { |
|
caStore: caStore, |
|
cipherSuites: options.cipherSuites || null, |
|
virtualHost: options.virtualHost || url.host, |
|
verify: options.verify || _defaultCertificateVerify, |
|
getCertificate: options.getCertificate || null, |
|
getPrivateKey: options.getPrivateKey || null, |
|
getSignature: options.getSignature || null, |
|
prime: options.primeTlsSockets || false |
|
}; |
|
|
|
// if socket pool uses a flash api, then add deflate support to TLS |
|
if(sp.flashApi !== null) { |
|
tlsOptions.deflate = function(bytes) { |
|
// strip 2 byte zlib header and 4 byte trailer |
|
return forge.util.deflate(sp.flashApi, bytes, true); |
|
}; |
|
tlsOptions.inflate = function(bytes) { |
|
return forge.util.inflate(sp.flashApi, bytes, true); |
|
}; |
|
} |
|
} |
|
|
|
// create and initialize sockets |
|
for(var i = 0; i < options.connections; ++i) { |
|
_initSocket(client, sp.createSocket(), tlsOptions); |
|
} |
|
|
|
/** |
|
* Sends a request. A method 'abort' will be set on the request that |
|
* can be called to attempt to abort the request. |
|
* |
|
* @param options: |
|
* request: the request to send. |
|
* connected: a callback for when the connection is open. |
|
* closed: a callback for when the connection is closed. |
|
* headerReady: a callback for when the response header arrives. |
|
* bodyReady: a callback for when the response body arrives. |
|
* error: a callback for if an error occurs. |
|
*/ |
|
client.send = function(options) { |
|
// add host header if not set |
|
if(options.request.getField('Host') === null) { |
|
options.request.setField('Host', client.url.fullHost); |
|
} |
|
|
|
// set default dummy handlers |
|
var opts = {}; |
|
opts.request = options.request; |
|
opts.connected = options.connected || function() {}; |
|
opts.closed = options.close || function() {}; |
|
opts.headerReady = function(e) { |
|
// read cookies |
|
_readCookies(client, e.response); |
|
if(options.headerReady) { |
|
options.headerReady(e); |
|
} |
|
}; |
|
opts.bodyReady = options.bodyReady || function() {}; |
|
opts.error = options.error || function() {}; |
|
|
|
// create response |
|
opts.response = http.createResponse(); |
|
opts.response.time = 0; |
|
opts.response.flashApi = client.socketPool.flashApi; |
|
opts.request.flashApi = client.socketPool.flashApi; |
|
|
|
// create abort function |
|
opts.request.abort = function() { |
|
// set aborted, clear handlers |
|
opts.request.aborted = true; |
|
opts.connected = function() {}; |
|
opts.closed = function() {}; |
|
opts.headerReady = function() {}; |
|
opts.bodyReady = function() {}; |
|
opts.error = function() {}; |
|
}; |
|
|
|
// add cookies to request |
|
_writeCookies(client, opts.request); |
|
|
|
// queue request options if there are no idle sockets |
|
if(client.idle.length === 0) { |
|
client.requests.push(opts); |
|
} else { |
|
// use an idle socket, prefer an idle *connected* socket first |
|
var socket = null; |
|
var len = client.idle.length; |
|
for(var i = 0; socket === null && i < len; ++i) { |
|
socket = client.idle[i]; |
|
if(socket.isConnected()) { |
|
client.idle.splice(i, 1); |
|
} else { |
|
socket = null; |
|
} |
|
} |
|
// no connected socket available, get unconnected socket |
|
if(socket === null) { |
|
socket = client.idle.pop(); |
|
} |
|
socket.options = opts; |
|
_doRequest(client, socket); |
|
} |
|
}; |
|
|
|
/** |
|
* Destroys this client. |
|
*/ |
|
client.destroy = function() { |
|
// clear pending requests, close and destroy sockets |
|
client.requests = []; |
|
for(var i = 0; i < client.sockets.length; ++i) { |
|
client.sockets[i].close(); |
|
client.sockets[i].destroy(); |
|
} |
|
client.socketPool = null; |
|
client.sockets = []; |
|
client.idle = []; |
|
}; |
|
|
|
/** |
|
* Sets a cookie for use with all connections made by this client. Any |
|
* cookie with the same name will be replaced. If the cookie's value |
|
* is undefined, null, or the blank string, the cookie will be removed. |
|
* |
|
* If the cookie's domain doesn't match this client's url host or the |
|
* cookie's secure flag doesn't match this client's url scheme, then |
|
* setting the cookie will fail with an exception. |
|
* |
|
* @param cookie the cookie with parameters: |
|
* name: the name of the cookie. |
|
* value: the value of the cookie. |
|
* comment: an optional comment string. |
|
* maxAge: the age of the cookie in seconds relative to created time. |
|
* secure: true if the cookie must be sent over a secure protocol. |
|
* httpOnly: true to restrict access to the cookie from javascript |
|
* (inaffective since the cookies are stored in javascript). |
|
* path: the path for the cookie. |
|
* domain: optional domain the cookie belongs to (must start with dot). |
|
* version: optional version of the cookie. |
|
* created: creation time, in UTC seconds, of the cookie. |
|
*/ |
|
client.setCookie = function(cookie) { |
|
var rval; |
|
if(typeof(cookie.name) !== 'undefined') { |
|
if(cookie.value === null || typeof(cookie.value) === 'undefined' || |
|
cookie.value === '') { |
|
// remove cookie |
|
rval = client.removeCookie(cookie.name, cookie.path); |
|
} else { |
|
// set cookie defaults |
|
cookie.comment = cookie.comment || ''; |
|
cookie.maxAge = cookie.maxAge || 0; |
|
cookie.secure = (typeof(cookie.secure) === 'undefined') ? |
|
true : cookie.secure; |
|
cookie.httpOnly = cookie.httpOnly || true; |
|
cookie.path = cookie.path || '/'; |
|
cookie.domain = cookie.domain || null; |
|
cookie.version = cookie.version || null; |
|
cookie.created = _getUtcTime(new Date()); |
|
|
|
// do secure check |
|
if(cookie.secure !== client.secure) { |
|
var error = new Error('Http client url scheme is incompatible ' + |
|
'with cookie secure flag.'); |
|
error.url = client.url; |
|
error.cookie = cookie; |
|
throw error; |
|
} |
|
// make sure url host is within cookie.domain |
|
if(!http.withinCookieDomain(client.url, cookie)) { |
|
var error = new Error('Http client url scheme is incompatible ' + |
|
'with cookie secure flag.'); |
|
error.url = client.url; |
|
error.cookie = cookie; |
|
throw error; |
|
} |
|
|
|
// add new cookie |
|
if(!(cookie.name in client.cookies)) { |
|
client.cookies[cookie.name] = {}; |
|
} |
|
client.cookies[cookie.name][cookie.path] = cookie; |
|
rval = true; |
|
|
|
// save cookies |
|
_saveCookies(client); |
|
} |
|
} |
|
|
|
return rval; |
|
}; |
|
|
|
/** |
|
* Gets a cookie by its name. |
|
* |
|
* @param name the name of the cookie to retrieve. |
|
* @param path an optional path for the cookie (if there are multiple |
|
* cookies with the same name but different paths). |
|
* |
|
* @return the cookie or null if not found. |
|
*/ |
|
client.getCookie = function(name, path) { |
|
var rval = null; |
|
if(name in client.cookies) { |
|
var paths = client.cookies[name]; |
|
|
|
// get path-specific cookie |
|
if(path) { |
|
if(path in paths) { |
|
rval = paths[path]; |
|
} |
|
} else { |
|
// get first cookie |
|
for(var p in paths) { |
|
rval = paths[p]; |
|
break; |
|
} |
|
} |
|
} |
|
return rval; |
|
}; |
|
|
|
/** |
|
* Removes a cookie. |
|
* |
|
* @param name the name of the cookie to remove. |
|
* @param path an optional path for the cookie (if there are multiple |
|
* cookies with the same name but different paths). |
|
* |
|
* @return true if a cookie was removed, false if not. |
|
*/ |
|
client.removeCookie = function(name, path) { |
|
var rval = false; |
|
if(name in client.cookies) { |
|
// delete the specific path |
|
if(path) { |
|
var paths = client.cookies[name]; |
|
if(path in paths) { |
|
rval = true; |
|
delete client.cookies[name][path]; |
|
// clean up entry if empty |
|
var empty = true; |
|
for(var i in client.cookies[name]) { |
|
empty = false; |
|
break; |
|
} |
|
if(empty) { |
|
delete client.cookies[name]; |
|
} |
|
} |
|
} else { |
|
// delete all cookies with the given name |
|
rval = true; |
|
delete client.cookies[name]; |
|
} |
|
} |
|
if(rval) { |
|
// save cookies |
|
_saveCookies(client); |
|
} |
|
return rval; |
|
}; |
|
|
|
/** |
|
* Clears all cookies stored in this client. |
|
*/ |
|
client.clearCookies = function() { |
|
client.cookies = {}; |
|
_clearCookies(client); |
|
}; |
|
|
|
if(forge.log) { |
|
forge.log.debug('forge.http', 'created client', options); |
|
} |
|
|
|
return client; |
|
}; |
|
|
|
/** |
|
* Trims the whitespace off of the beginning and end of a string. |
|
* |
|
* @param str the string to trim. |
|
* |
|
* @return the trimmed string. |
|
*/ |
|
var _trimString = function(str) { |
|
return str.replace(/^\s*/, '').replace(/\s*$/, ''); |
|
}; |
|
|
|
/** |
|
* Creates an http header object. |
|
* |
|
* @return the http header object. |
|
*/ |
|
var _createHeader = function() { |
|
var header = { |
|
fields: {}, |
|
setField: function(name, value) { |
|
// normalize field name, trim value |
|
header.fields[_normalize(name)] = [_trimString('' + value)]; |
|
}, |
|
appendField: function(name, value) { |
|
name = _normalize(name); |
|
if(!(name in header.fields)) { |
|
header.fields[name] = []; |
|
} |
|
header.fields[name].push(_trimString('' + value)); |
|
}, |
|
getField: function(name, index) { |
|
var rval = null; |
|
name = _normalize(name); |
|
if(name in header.fields) { |
|
index = index || 0; |
|
rval = header.fields[name][index]; |
|
} |
|
return rval; |
|
} |
|
}; |
|
return header; |
|
}; |
|
|
|
/** |
|
* Gets the time in utc seconds given a date. |
|
* |
|
* @param d the date to use. |
|
* |
|
* @return the time in utc seconds. |
|
*/ |
|
var _getUtcTime = function(d) { |
|
var utc = +d + d.getTimezoneOffset() * 60000; |
|
return Math.floor(+new Date() / 1000); |
|
}; |
|
|
|
/** |
|
* Creates an http request. |
|
* |
|
* @param options: |
|
* version: the version. |
|
* method: the method. |
|
* path: the path. |
|
* body: the body. |
|
* headers: custom header fields to add, |
|
* eg: [{'Content-Length': 0}]. |
|
* |
|
* @return the http request. |
|
*/ |
|
http.createRequest = function(options) { |
|
options = options || {}; |
|
var request = _createHeader(); |
|
request.version = options.version || 'HTTP/1.1'; |
|
request.method = options.method || null; |
|
request.path = options.path || null; |
|
request.body = options.body || null; |
|
request.bodyDeflated = false; |
|
request.flashApi = null; |
|
|
|
// add custom headers |
|
var headers = options.headers || []; |
|
if(!forge.util.isArray(headers)) { |
|
headers = [headers]; |
|
} |
|
for(var i = 0; i < headers.length; ++i) { |
|
for(var name in headers[i]) { |
|
request.appendField(name, headers[i][name]); |
|
} |
|
} |
|
|
|
/** |
|
* Adds a cookie to the request 'Cookie' header. |
|
* |
|
* @param cookie a cookie to add. |
|
*/ |
|
request.addCookie = function(cookie) { |
|
var value = ''; |
|
var field = request.getField('Cookie'); |
|
if(field !== null) { |
|
// separate cookies by semi-colons |
|
value = field + '; '; |
|
} |
|
|
|
// get current time in utc seconds |
|
var now = _getUtcTime(new Date()); |
|
|
|
// output cookie name and value |
|
value += cookie.name + '=' + cookie.value; |
|
request.setField('Cookie', value); |
|
}; |
|
|
|
/** |
|
* Converts an http request into a string that can be sent as an |
|
* HTTP request. Does not include any data. |
|
* |
|
* @return the string representation of the request. |
|
*/ |
|
request.toString = function() { |
|
/* Sample request header: |
|
GET /some/path/?query HTTP/1.1 |
|
Host: www.someurl.com |
|
Connection: close |
|
Accept-Encoding: deflate |
|
Accept: image/gif, text/html |
|
User-Agent: Mozilla 4.0 |
|
*/ |
|
|
|
// set default headers |
|
if(request.getField('User-Agent') === null) { |
|
request.setField('User-Agent', 'forge.http 1.0'); |
|
} |
|
if(request.getField('Accept') === null) { |
|
request.setField('Accept', '*/*'); |
|
} |
|
if(request.getField('Connection') === null) { |
|
request.setField('Connection', 'keep-alive'); |
|
request.setField('Keep-Alive', '115'); |
|
} |
|
|
|
// add Accept-Encoding if not specified |
|
if(request.flashApi !== null && |
|
request.getField('Accept-Encoding') === null) { |
|
request.setField('Accept-Encoding', 'deflate'); |
|
} |
|
|
|
// if the body isn't null, deflate it if its larger than 100 bytes |
|
if(request.flashApi !== null && request.body !== null && |
|
request.getField('Content-Encoding') === null && |
|
!request.bodyDeflated && request.body.length > 100) { |
|
// use flash to compress data |
|
request.body = forge.util.deflate(request.flashApi, request.body); |
|
request.bodyDeflated = true; |
|
request.setField('Content-Encoding', 'deflate'); |
|
request.setField('Content-Length', request.body.length); |
|
} else if(request.body !== null) { |
|
// set content length for body |
|
request.setField('Content-Length', request.body.length); |
|
} |
|
|
|
// build start line |
|
var rval = |
|
request.method.toUpperCase() + ' ' + request.path + ' ' + |
|
request.version + '\r\n'; |
|
|
|
// add each header |
|
for(var name in request.fields) { |
|
var fields = request.fields[name]; |
|
for(var i = 0; i < fields.length; ++i) { |
|
rval += name + ': ' + fields[i] + '\r\n'; |
|
} |
|
} |
|
// final terminating CRLF |
|
rval += '\r\n'; |
|
|
|
return rval; |
|
}; |
|
|
|
return request; |
|
}; |
|
|
|
/** |
|
* Creates an empty http response header. |
|
* |
|
* @return the empty http response header. |
|
*/ |
|
http.createResponse = function() { |
|
// private vars |
|
var _first = true; |
|
var _chunkSize = 0; |
|
var _chunksFinished = false; |
|
|
|
// create response |
|
var response = _createHeader(); |
|
response.version = null; |
|
response.code = 0; |
|
response.message = null; |
|
response.body = null; |
|
response.headerReceived = false; |
|
response.bodyReceived = false; |
|
response.flashApi = null; |
|
|
|
/** |
|
* Reads a line that ends in CRLF from a byte buffer. |
|
* |
|
* @param b the byte buffer. |
|
* |
|
* @return the line or null if none was found. |
|
*/ |
|
var _readCrlf = function(b) { |
|
var line = null; |
|
var i = b.data.indexOf('\r\n', b.read); |
|
if(i != -1) { |
|
// read line, skip CRLF |
|
line = b.getBytes(i - b.read); |
|
b.getBytes(2); |
|
} |
|
return line; |
|
}; |
|
|
|
/** |
|
* Parses a header field and appends it to the response. |
|
* |
|
* @param line the header field line. |
|
*/ |
|
var _parseHeader = function(line) { |
|
var tmp = line.indexOf(':'); |
|
var name = line.substring(0, tmp++); |
|
response.appendField( |
|
name, (tmp < line.length) ? line.substring(tmp) : ''); |
|
}; |
|
|
|
/** |
|
* Reads an http response header from a buffer of bytes. |
|
* |
|
* @param b the byte buffer to parse the header from. |
|
* |
|
* @return true if the whole header was read, false if not. |
|
*/ |
|
response.readHeader = function(b) { |
|
// read header lines (each ends in CRLF) |
|
var line = ''; |
|
while(!response.headerReceived && line !== null) { |
|
line = _readCrlf(b); |
|
if(line !== null) { |
|
// parse first line |
|
if(_first) { |
|
_first = false; |
|
var tmp = line.split(' '); |
|
if(tmp.length >= 3) { |
|
response.version = tmp[0]; |
|
response.code = parseInt(tmp[1], 10); |
|
response.message = tmp.slice(2).join(' '); |
|
} else { |
|
// invalid header |
|
var error = new Error('Invalid http response header.'); |
|
error.details = {'line': line}; |
|
throw error; |
|
} |
|
} else if(line.length === 0) { |
|
// handle final line, end of header |
|
response.headerReceived = true; |
|
} else { |
|
_parseHeader(line); |
|
} |
|
} |
|
} |
|
|
|
return response.headerReceived; |
|
}; |
|
|
|
/** |
|
* Reads some chunked http response entity-body from the given buffer of |
|
* bytes. |
|
* |
|
* @param b the byte buffer to read from. |
|
* |
|
* @return true if the whole body was read, false if not. |
|
*/ |
|
var _readChunkedBody = function(b) { |
|
/* Chunked transfer-encoding sends data in a series of chunks, |
|
followed by a set of 0-N http trailers. |
|
The format is as follows: |
|
|
|
chunk-size (in hex) CRLF |
|
chunk data (with "chunk-size" many bytes) CRLF |
|
... (N many chunks) |
|
chunk-size (of 0 indicating the last chunk) CRLF |
|
N many http trailers followed by CRLF |
|
blank line + CRLF (terminates the trailers) |
|
|
|
If there are no http trailers, then after the chunk-size of 0, |
|
there is still a single CRLF (indicating the blank line + CRLF |
|
that terminates the trailers). In other words, you always terminate |
|
the trailers with blank line + CRLF, regardless of 0-N trailers. */ |
|
|
|
/* From RFC-2616, section 3.6.1, here is the pseudo-code for |
|
implementing chunked transfer-encoding: |
|
|
|
length := 0 |
|
read chunk-size, chunk-extension (if any) and CRLF |
|
while (chunk-size > 0) { |
|
read chunk-data and CRLF |
|
append chunk-data to entity-body |
|
length := length + chunk-size |
|
read chunk-size and CRLF |
|
} |
|
read entity-header |
|
while (entity-header not empty) { |
|
append entity-header to existing header fields |
|
read entity-header |
|
} |
|
Content-Length := length |
|
Remove "chunked" from Transfer-Encoding |
|
*/ |
|
|
|
var line = ''; |
|
while(line !== null && b.length() > 0) { |
|
// if in the process of reading a chunk |
|
if(_chunkSize > 0) { |
|
// if there are not enough bytes to read chunk and its |
|
// trailing CRLF, we must wait for more data to be received |
|
if(_chunkSize + 2 > b.length()) { |
|
break; |
|
} |
|
|
|
// read chunk data, skip CRLF |
|
response.body += b.getBytes(_chunkSize); |
|
b.getBytes(2); |
|
_chunkSize = 0; |
|
} else if(!_chunksFinished) { |
|
// more chunks, read next chunk-size line |
|
line = _readCrlf(b); |
|
if(line !== null) { |
|
// parse chunk-size (ignore any chunk extension) |
|
_chunkSize = parseInt(line.split(';', 1)[0], 16); |
|
_chunksFinished = (_chunkSize === 0); |
|
} |
|
} else { |
|
// chunks finished, read next trailer |
|
line = _readCrlf(b); |
|
while(line !== null) { |
|
if(line.length > 0) { |
|
// parse trailer |
|
_parseHeader(line); |
|
// read next trailer |
|
line = _readCrlf(b); |
|
} else { |
|
// body received |
|
response.bodyReceived = true; |
|
line = null; |
|
} |
|
} |
|
} |
|
} |
|
|
|
return response.bodyReceived; |
|
}; |
|
|
|
/** |
|
* Reads an http response body from a buffer of bytes. |
|
* |
|
* @param b the byte buffer to read from. |
|
* |
|
* @return true if the whole body was read, false if not. |
|
*/ |
|
response.readBody = function(b) { |
|
var contentLength = response.getField('Content-Length'); |
|
var transferEncoding = response.getField('Transfer-Encoding'); |
|
if(contentLength !== null) { |
|
contentLength = parseInt(contentLength); |
|
} |
|
|
|
// read specified length |
|
if(contentLength !== null && contentLength >= 0) { |
|
response.body = response.body || ''; |
|
response.body += b.getBytes(contentLength); |
|
response.bodyReceived = (response.body.length === contentLength); |
|
} else if(transferEncoding !== null) { |
|
// read chunked encoding |
|
if(transferEncoding.indexOf('chunked') != -1) { |
|
response.body = response.body || ''; |
|
_readChunkedBody(b); |
|
} else { |
|
var error = new Error('Unknown Transfer-Encoding.'); |
|
error.details = {'transferEncoding': transferEncoding}; |
|
throw error; |
|
} |
|
} else if((contentLength !== null && contentLength < 0) || |
|
(contentLength === null && |
|
response.getField('Content-Type') !== null)) { |
|
// read all data in the buffer |
|
response.body = response.body || ''; |
|
response.body += b.getBytes(); |
|
response.readBodyUntilClose = true; |
|
} else { |
|
// no body |
|
response.body = null; |
|
response.bodyReceived = true; |
|
} |
|
|
|
if(response.bodyReceived) { |
|
response.time = +new Date() - response.time; |
|
} |
|
|
|
if(response.flashApi !== null && |
|
response.bodyReceived && response.body !== null && |
|
response.getField('Content-Encoding') === 'deflate') { |
|
// inflate using flash api |
|
response.body = forge.util.inflate( |
|
response.flashApi, response.body); |
|
} |
|
|
|
return response.bodyReceived; |
|
}; |
|
|
|
/** |
|
* Parses an array of cookies from the 'Set-Cookie' field, if present. |
|
* |
|
* @return the array of cookies. |
|
*/ |
|
response.getCookies = function() { |
|
var rval = []; |
|
|
|
// get Set-Cookie field |
|
if('Set-Cookie' in response.fields) { |
|
var field = response.fields['Set-Cookie']; |
|
|
|
// get current local time in seconds |
|
var now = +new Date() / 1000; |
|
|
|
// regex for parsing 'name1=value1; name2=value2; name3' |
|
var regex = /\s*([^=]*)=?([^;]*)(;|$)/g; |
|
|
|
// examples: |
|
// Set-Cookie: cookie1_name=cookie1_value; max-age=0; path=/ |
|
// Set-Cookie: c2=v2; expires=Thu, 21-Aug-2008 23:47:25 GMT; path=/ |
|
for(var i = 0; i < field.length; ++i) { |
|
var fv = field[i]; |
|
var m; |
|
regex.lastIndex = 0; |
|
var first = true; |
|
var cookie = {}; |
|
do { |
|
m = regex.exec(fv); |
|
if(m !== null) { |
|
var name = _trimString(m[1]); |
|
var value = _trimString(m[2]); |
|
|
|
// cookie_name=value |
|
if(first) { |
|
cookie.name = name; |
|
cookie.value = value; |
|
first = false; |
|
} else { |
|
// property_name=value |
|
name = name.toLowerCase(); |
|
switch(name) { |
|
case 'expires': |
|
// replace hyphens w/spaces so date will parse |
|
value = value.replace(/-/g, ' '); |
|
var secs = Date.parse(value) / 1000; |
|
cookie.maxAge = Math.max(0, secs - now); |
|
break; |
|
case 'max-age': |
|
cookie.maxAge = parseInt(value, 10); |
|
break; |
|
case 'secure': |
|
cookie.secure = true; |
|
break; |
|
case 'httponly': |
|
cookie.httpOnly = true; |
|
break; |
|
default: |
|
if(name !== '') { |
|
cookie[name] = value; |
|
} |
|
} |
|
} |
|
} |
|
} while(m !== null && m[0] !== ''); |
|
rval.push(cookie); |
|
} |
|
} |
|
|
|
return rval; |
|
}; |
|
|
|
/** |
|
* Converts an http response into a string that can be sent as an |
|
* HTTP response. Does not include any data. |
|
* |
|
* @return the string representation of the response. |
|
*/ |
|
response.toString = function() { |
|
/* Sample response header: |
|
HTTP/1.0 200 OK |
|
Host: www.someurl.com |
|
Connection: close |
|
*/ |
|
|
|
// build start line |
|
var rval = |
|
response.version + ' ' + response.code + ' ' + response.message + '\r\n'; |
|
|
|
// add each header |
|
for(var name in response.fields) { |
|
var fields = response.fields[name]; |
|
for(var i = 0; i < fields.length; ++i) { |
|
rval += name + ': ' + fields[i] + '\r\n'; |
|
} |
|
} |
|
// final terminating CRLF |
|
rval += '\r\n'; |
|
|
|
return rval; |
|
}; |
|
|
|
return response; |
|
}; |
|
|
|
/** |
|
* Parses the scheme, host, and port from an http(s) url. |
|
* |
|
* @param str the url string. |
|
* |
|
* @return the parsed url object or null if the url is invalid. |
|
*/ |
|
http.parseUrl = forge.util.parseUrl; |
|
|
|
/** |
|
* Returns true if the given url is within the given cookie's domain. |
|
* |
|
* @param url the url to check. |
|
* @param cookie the cookie or cookie domain to check. |
|
*/ |
|
http.withinCookieDomain = function(url, cookie) { |
|
var rval = false; |
|
|
|
// cookie may be null, a cookie object, or a domain string |
|
var domain = (cookie === null || typeof cookie === 'string') ? |
|
cookie : cookie.domain; |
|
|
|
// any domain will do |
|
if(domain === null) { |
|
rval = true; |
|
} else if(domain.charAt(0) === '.') { |
|
// ensure domain starts with a '.' |
|
// parse URL as necessary |
|
if(typeof url === 'string') { |
|
url = http.parseUrl(url); |
|
} |
|
|
|
// add '.' to front of URL host to match against domain |
|
var host = '.' + url.host; |
|
|
|
// if the host ends with domain then it falls within it |
|
var idx = host.lastIndexOf(domain); |
|
if(idx !== -1 && (idx + domain.length === host.length)) { |
|
rval = true; |
|
} |
|
} |
|
|
|
return rval; |
|
};
|
|
|