| 1 | var CombinedStream = require('combined-stream'); |
| 2 | var util = require('util'); |
| 3 | var path = require('path'); |
| 4 | var http = require('http'); |
| 5 | var https = require('https'); |
| 6 | var parseUrl = require('url').parse; |
| 7 | var fs = require('fs'); |
| 8 | var mime = require('mime-types'); |
| 9 | var asynckit = require('asynckit'); |
| 10 | var populate = require('./populate.js'); |
| 11 | |
| 12 | // Public API |
| 13 | module.exports = FormData; |
| 14 | |
| 15 | // make it a Stream |
| 16 | util.inherits(FormData, CombinedStream); |
| 17 | |
| 18 | /** |
| 19 | * Create readable "multipart/form-data" streams. |
| 20 | * Can be used to submit forms |
| 21 | * and file uploads to other web applications. |
| 22 | * |
| 23 | * @constructor |
| 24 | * @param {Object} options - Properties to be added/overriden for FormData and CombinedStream |
| 25 | */ |
| 26 | function FormData(options) { |
| 27 | if (!(this instanceof FormData)) { |
| 28 | return new FormData(); |
| 29 | } |
| 30 | |
| 31 | this._overheadLength = 0; |
| 32 | this._valueLength = 0; |
| 33 | this._valuesToMeasure = []; |
| 34 | |
| 35 | CombinedStream.call(this); |
| 36 | |
| 37 | options = options || {}; |
| 38 | for (var option in options) { |
| 39 | this[option] = options[option]; |
| 40 | } |
| 41 | } |
| 42 | |
| 43 | FormData.LINE_BREAK = '\r\n'; |
| 44 | FormData.DEFAULT_CONTENT_TYPE = 'application/octet-stream'; |
| 45 | |
| 46 | FormData.prototype.append = function(field, value, options) { |
| 47 | |
| 48 | options = options || {}; |
| 49 | |
| 50 | // allow filename as single option |
| 51 | if (typeof options == 'string') { |
| 52 | options = {filename: options}; |
| 53 | } |
| 54 | |
| 55 | var append = CombinedStream.prototype.append.bind(this); |
| 56 | |
| 57 | // all that streamy business can't handle numbers |
| 58 | if (typeof value == 'number') { |
| 59 | value = '' + value; |
| 60 | } |
| 61 | |
| 62 | // https://github.com/felixge/node-form-data/issues/38 |
| 63 | if (util.isArray(value)) { |
| 64 | // Please convert your array into string |
| 65 | // the way web server expects it |
| 66 | this._error(new Error('Arrays are not supported.')); |
| 67 | return; |
| 68 | } |
| 69 | |
| 70 | var header = this._multiPartHeader(field, value, options); |
| 71 | var footer = this._multiPartFooter(); |
| 72 | |
| 73 | append(header); |
| 74 | append(value); |
| 75 | append(footer); |
| 76 | |
| 77 | // pass along options.knownLength |
| 78 | this._trackLength(header, value, options); |
| 79 | }; |
| 80 | |
| 81 | FormData.prototype._trackLength = function(header, value, options) { |
| 82 | var valueLength = 0; |
| 83 | |
| 84 | // used w/ getLengthSync(), when length is known. |
| 85 | // e.g. for streaming directly from a remote server, |
| 86 | // w/ a known file a size, and not wanting to wait for |
| 87 | // incoming file to finish to get its size. |
| 88 | if (options.knownLength != null) { |
| 89 | valueLength += +options.knownLength; |
| 90 | } else if (Buffer.isBuffer(value)) { |
| 91 | valueLength = value.length; |
| 92 | } else if (typeof value === 'string') { |
| 93 | valueLength = Buffer.byteLength(value); |
| 94 | } |
| 95 | |
| 96 | this._valueLength += valueLength; |
| 97 | |
| 98 | // @check why add CRLF? does this account for custom/multiple CRLFs? |
| 99 | this._overheadLength += |
| 100 | Buffer.byteLength(header) + |
| 101 | FormData.LINE_BREAK.length; |
| 102 | |
| 103 | // empty or either doesn't have path or not an http response |
| 104 | if (!value || ( !value.path && !(value.readable && value.hasOwnProperty('httpVersion')) )) { |
| 105 | return; |
| 106 | } |
| 107 | |
| 108 | // no need to bother with the length |
| 109 | if (!options.knownLength) { |
| 110 | this._valuesToMeasure.push(value); |
| 111 | } |
| 112 | }; |
| 113 | |
| 114 | FormData.prototype._lengthRetriever = function(value, callback) { |
| 115 | |
| 116 | if (value.hasOwnProperty('fd')) { |
| 117 | |
| 118 | // take read range into a account |
| 119 | // `end` = Infinity –> read file till the end |
| 120 | // |
| 121 | // TODO: Looks like there is bug in Node fs.createReadStream |
| 122 | // it doesn't respect `end` options without `start` options |
| 123 | // Fix it when node fixes it. |
| 124 | // https://github.com/joyent/node/issues/7819 |
| 125 | if (value.end != undefined && value.end != Infinity && value.start != undefined) { |
| 126 | |
| 127 | // when end specified |
| 128 | // no need to calculate range |
| 129 | // inclusive, starts with 0 |
| 130 | callback(null, value.end + 1 - (value.start ? value.start : 0)); |
| 131 | |
| 132 | // not that fast snoopy |
| 133 | } else { |
| 134 | // still need to fetch file size from fs |
| 135 | fs.stat(value.path, function(err, stat) { |
| 136 | |
| 137 | var fileSize; |
| 138 | |
| 139 | if (err) { |
| 140 | callback(err); |
| 141 | return; |
| 142 | } |
| 143 | |
| 144 | // update final size based on the range options |
| 145 | fileSize = stat.size - (value.start ? value.start : 0); |
| 146 | callback(null, fileSize); |
| 147 | }); |
| 148 | } |
| 149 | |
| 150 | // or http response |
| 151 | } else if (value.hasOwnProperty('httpVersion')) { |
| 152 | callback(null, +value.headers['content-length']); |
| 153 | |
| 154 | // or request stream http://github.com/mikeal/request |
| 155 | } else if (value.hasOwnProperty('httpModule')) { |
| 156 | // wait till response come back |
| 157 | value.on('response', function(response) { |
| 158 | value.pause(); |
| 159 | callback(null, +response.headers['content-length']); |
| 160 | }); |
| 161 | value.resume(); |
| 162 | |
| 163 | // something else |
| 164 | } else { |
| 165 | callback('Unknown stream'); |
| 166 | } |
| 167 | }; |
| 168 | |
| 169 | FormData.prototype._multiPartHeader = function(field, value, options) { |
| 170 | // custom header specified (as string)? |
| 171 | // it becomes responsible for boundary |
| 172 | // (e.g. to handle extra CRLFs on .NET servers) |
| 173 | if (typeof options.header == 'string') { |
| 174 | return options.header; |
| 175 | } |
| 176 | |
| 177 | var contentDisposition = this._getContentDisposition(value, options); |
| 178 | var contentType = this._getContentType(value, options); |
| 179 | |
| 180 | var contents = ''; |
| 181 | var headers = { |
| 182 | // add custom disposition as third element or keep it two elements if not |
| 183 | 'Content-Disposition': ['form-data', 'name="' + field + '"'].concat(contentDisposition || []), |
| 184 | // if no content type. allow it to be empty array |
| 185 | 'Content-Type': [].concat(contentType || []) |
| 186 | }; |
| 187 | |
| 188 | // allow custom headers. |
| 189 | if (typeof options.header == 'object') { |
| 190 | populate(headers, options.header); |
| 191 | } |
| 192 | |
| 193 | var header; |
| 194 | for (var prop in headers) { |
| 195 | if (!headers.hasOwnProperty(prop)) continue; |
| 196 | header = headers[prop]; |
| 197 | |
| 198 | // skip nullish headers. |
| 199 | if (header == null) { |
| 200 | continue; |
| 201 | } |
| 202 | |
| 203 | // convert all headers to arrays. |
| 204 | if (!Array.isArray(header)) { |
| 205 | header = [header]; |
| 206 | } |
| 207 | |
| 208 | // add non-empty headers. |
| 209 | if (header.length) { |
| 210 | contents += prop + ': ' + header.join('; ') + FormData.LINE_BREAK; |
| 211 | } |
| 212 | } |
| 213 | |
| 214 | return '--' + this.getBoundary() + FormData.LINE_BREAK + contents + FormData.LINE_BREAK; |
| 215 | }; |
| 216 | |
| 217 | FormData.prototype._getContentDisposition = function(value, options) { |
| 218 | |
| 219 | var filename |
| 220 | , contentDisposition |
| 221 | ; |
| 222 | |
| 223 | if (typeof options.filepath === 'string') { |
| 224 | // custom filepath for relative paths |
| 225 | filename = path.normalize(options.filepath).replace(/\\/g, '/'); |
| 226 | } else if (options.filename || value.name || value.path) { |
| 227 | // custom filename take precedence |
| 228 | // formidable and the browser add a name property |
| 229 | // fs- and request- streams have path property |
| 230 | filename = path.basename(options.filename || value.name || value.path); |
| 231 | } else if (value.readable && value.hasOwnProperty('httpVersion')) { |
| 232 | // or try http response |
| 233 | filename = path.basename(value.client._httpMessage.path); |
| 234 | } |
| 235 | |
| 236 | if (filename) { |
| 237 | contentDisposition = 'filename="' + filename + '"'; |
| 238 | } |
| 239 | |
| 240 | return contentDisposition; |
| 241 | }; |
| 242 | |
| 243 | FormData.prototype._getContentType = function(value, options) { |
| 244 | |
| 245 | // use custom content-type above all |
| 246 | var contentType = options.contentType; |
| 247 | |
| 248 | // or try `name` from formidable, browser |
| 249 | if (!contentType && value.name) { |
| 250 | contentType = mime.lookup(value.name); |
| 251 | } |
| 252 | |
| 253 | // or try `path` from fs-, request- streams |
| 254 | if (!contentType && value.path) { |
| 255 | contentType = mime.lookup(value.path); |
| 256 | } |
| 257 | |
| 258 | // or if it's http-reponse |
| 259 | if (!contentType && value.readable && value.hasOwnProperty('httpVersion')) { |
| 260 | contentType = value.headers['content-type']; |
| 261 | } |
| 262 | |
| 263 | // or guess it from the filepath or filename |
| 264 | if (!contentType && (options.filepath || options.filename)) { |
| 265 | contentType = mime.lookup(options.filepath || options.filename); |
| 266 | } |
| 267 | |
| 268 | // fallback to the default content type if `value` is not simple value |
| 269 | if (!contentType && typeof value == 'object') { |
| 270 | contentType = FormData.DEFAULT_CONTENT_TYPE; |
| 271 | } |
| 272 | |
| 273 | return contentType; |
| 274 | }; |
| 275 | |
| 276 | FormData.prototype._multiPartFooter = function() { |
| 277 | return function(next) { |
| 278 | var footer = FormData.LINE_BREAK; |
| 279 | |
| 280 | var lastPart = (this._streams.length === 0); |
| 281 | if (lastPart) { |
| 282 | footer += this._lastBoundary(); |
| 283 | } |
| 284 | |
| 285 | next(footer); |
| 286 | }.bind(this); |
| 287 | }; |
| 288 | |
| 289 | FormData.prototype._lastBoundary = function() { |
| 290 | return '--' + this.getBoundary() + '--' + FormData.LINE_BREAK; |
| 291 | }; |
| 292 | |
| 293 | FormData.prototype.getHeaders = function(userHeaders) { |
| 294 | var header; |
| 295 | var formHeaders = { |
| 296 | 'content-type': 'multipart/form-data; boundary=' + this.getBoundary() |
| 297 | }; |
| 298 | |
| 299 | for (header in userHeaders) { |
| 300 | if (userHeaders.hasOwnProperty(header)) { |
| 301 | formHeaders[header.toLowerCase()] = userHeaders[header]; |
| 302 | } |
| 303 | } |
| 304 | |
| 305 | return formHeaders; |
| 306 | }; |
| 307 | |
| 308 | FormData.prototype.getBoundary = function() { |
| 309 | if (!this._boundary) { |
| 310 | this._generateBoundary(); |
| 311 | } |
| 312 | |
| 313 | return this._boundary; |
| 314 | }; |
| 315 | |
| 316 | FormData.prototype._generateBoundary = function() { |
| 317 | // This generates a 50 character boundary similar to those used by Firefox. |
| 318 | // They are optimized for boyer-moore parsing. |
| 319 | var boundary = '--------------------------'; |
| 320 | for (var i = 0; i < 24; i++) { |
| 321 | boundary += Math.floor(Math.random() * 10).toString(16); |
| 322 | } |
| 323 | |
| 324 | this._boundary = boundary; |
| 325 | }; |
| 326 | |
| 327 | // Note: getLengthSync DOESN'T calculate streams length |
| 328 | // As workaround one can calculate file size manually |
| 329 | // and add it as knownLength option |
| 330 | FormData.prototype.getLengthSync = function() { |
| 331 | var knownLength = this._overheadLength + this._valueLength; |
| 332 | |
| 333 | // Don't get confused, there are 3 "internal" streams for each keyval pair |
| 334 | // so it basically checks if there is any value added to the form |
| 335 | if (this._streams.length) { |
| 336 | knownLength += this._lastBoundary().length; |
| 337 | } |
| 338 | |
| 339 | // https://github.com/form-data/form-data/issues/40 |
| 340 | if (!this.hasKnownLength()) { |
| 341 | // Some async length retrievers are present |
| 342 | // therefore synchronous length calculation is false. |
| 343 | // Please use getLength(callback) to get proper length |
| 344 | this._error(new Error('Cannot calculate proper length in synchronous way.')); |
| 345 | } |
| 346 | |
| 347 | return knownLength; |
| 348 | }; |
| 349 | |
| 350 | // Public API to check if length of added values is known |
| 351 | // https://github.com/form-data/form-data/issues/196 |
| 352 | // https://github.com/form-data/form-data/issues/262 |
| 353 | FormData.prototype.hasKnownLength = function() { |
| 354 | var hasKnownLength = true; |
| 355 | |
| 356 | if (this._valuesToMeasure.length) { |
| 357 | hasKnownLength = false; |
| 358 | } |
| 359 | |
| 360 | return hasKnownLength; |
| 361 | }; |
| 362 | |
| 363 | FormData.prototype.getLength = function(cb) { |
| 364 | var knownLength = this._overheadLength + this._valueLength; |
| 365 | |
| 366 | if (this._streams.length) { |
| 367 | knownLength += this._lastBoundary().length; |
| 368 | } |
| 369 | |
| 370 | if (!this._valuesToMeasure.length) { |
| 371 | process.nextTick(cb.bind(this, null, knownLength)); |
| 372 | return; |
| 373 | } |
| 374 | |
| 375 | asynckit.parallel(this._valuesToMeasure, this._lengthRetriever, function(err, values) { |
| 376 | if (err) { |
| 377 | cb(err); |
| 378 | return; |
| 379 | } |
| 380 | |
| 381 | values.forEach(function(length) { |
| 382 | knownLength += length; |
| 383 | }); |
| 384 | |
| 385 | cb(null, knownLength); |
| 386 | }); |
| 387 | }; |
| 388 | |
| 389 | FormData.prototype.submit = function(params, cb) { |
| 390 | var request |
| 391 | , options |
| 392 | , defaults = {method: 'post'} |
| 393 | ; |
| 394 | |
| 395 | // parse provided url if it's string |
| 396 | // or treat it as options object |
| 397 | if (typeof params == 'string') { |
| 398 | |
| 399 | params = parseUrl(params); |
| 400 | options = populate({ |
| 401 | port: params.port, |
| 402 | path: params.pathname, |
| 403 | host: params.hostname, |
| 404 | protocol: params.protocol |
| 405 | }, defaults); |
| 406 | |
| 407 | // use custom params |
| 408 | } else { |
| 409 | |
| 410 | options = populate(params, defaults); |
| 411 | // if no port provided use default one |
| 412 | if (!options.port) { |
| 413 | options.port = options.protocol == 'https:' ? 443 : 80; |
| 414 | } |
| 415 | } |
| 416 | |
| 417 | // put that good code in getHeaders to some use |
| 418 | options.headers = this.getHeaders(params.headers); |
| 419 | |
| 420 | // https if specified, fallback to http in any other case |
| 421 | if (options.protocol == 'https:') { |
| 422 | request = https.request(options); |
| 423 | } else { |
| 424 | request = http.request(options); |
| 425 | } |
| 426 | |
| 427 | // get content length and fire away |
| 428 | this.getLength(function(err, length) { |
| 429 | if (err) { |
| 430 | this._error(err); |
| 431 | return; |
| 432 | } |
| 433 | |
| 434 | // add content length |
| 435 | request.setHeader('Content-Length', length); |
| 436 | |
| 437 | this.pipe(request); |
| 438 | if (cb) { |
| 439 | request.on('error', cb); |
| 440 | request.on('response', cb.bind(this, null)); |
| 441 | } |
| 442 | }.bind(this)); |
| 443 | |
| 444 | return request; |
| 445 | }; |
| 446 | |
| 447 | FormData.prototype._error = function(err) { |
| 448 | if (!this.error) { |
| 449 | this.error = err; |
| 450 | this.pause(); |
| 451 | this.emit('error', err); |
| 452 | } |
| 453 | }; |
| 454 | |
| 455 | FormData.prototype.toString = function () { |
| 456 | return '[object FormData]'; |
| 457 | }; |