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(options);
 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.setBoundary = function(boundary) {
309    this._boundary = boundary;
310  };
311  
312  FormData.prototype.getBoundary = function() {
313    if (!this._boundary) {
314      this._generateBoundary();
315    }
316  
317    return this._boundary;
318  };
319  
320  FormData.prototype.getBuffer = function() {
321    var dataBuffer = new Buffer.alloc( 0 );
322    var boundary = this.getBoundary();
323  
324    // Create the form content. Add Line breaks to the end of data.
325    for (var i = 0, len = this._streams.length; i < len; i++) {
326      if (typeof this._streams[i] !== 'function') {
327  
328        // Add content to the buffer.
329        if(Buffer.isBuffer(this._streams[i])) {
330          dataBuffer = Buffer.concat( [dataBuffer, this._streams[i]]);
331        }else {
332          dataBuffer = Buffer.concat( [dataBuffer, Buffer.from(this._streams[i])]);
333        }
334  
335        // Add break after content.
336        if (typeof this._streams[i] !== 'string' || this._streams[i].substring( 2, boundary.length + 2 ) !== boundary) {
337          dataBuffer = Buffer.concat( [dataBuffer, Buffer.from(FormData.LINE_BREAK)] );
338        }
339      }
340    }
341  
342    // Add the footer and return the Buffer object.
343    return Buffer.concat( [dataBuffer, Buffer.from(this._lastBoundary())] );
344  };
345  
346  FormData.prototype._generateBoundary = function() {
347    // This generates a 50 character boundary similar to those used by Firefox.
348    // They are optimized for boyer-moore parsing.
349    var boundary = '--------------------------';
350    for (var i = 0; i < 24; i++) {
351      boundary += Math.floor(Math.random() * 10).toString(16);
352    }
353  
354    this._boundary = boundary;
355  };
356  
357  // Note: getLengthSync DOESN'T calculate streams length
358  // As workaround one can calculate file size manually
359  // and add it as knownLength option
360  FormData.prototype.getLengthSync = function() {
361    var knownLength = this._overheadLength + this._valueLength;
362  
363    // Don't get confused, there are 3 "internal" streams for each keyval pair
364    // so it basically checks if there is any value added to the form
365    if (this._streams.length) {
366      knownLength += this._lastBoundary().length;
367    }
368  
369    // https://github.com/form-data/form-data/issues/40
370    if (!this.hasKnownLength()) {
371      // Some async length retrievers are present
372      // therefore synchronous length calculation is false.
373      // Please use getLength(callback) to get proper length
374      this._error(new Error('Cannot calculate proper length in synchronous way.'));
375    }
376  
377    return knownLength;
378  };
379  
380  // Public API to check if length of added values is known
381  // https://github.com/form-data/form-data/issues/196
382  // https://github.com/form-data/form-data/issues/262
383  FormData.prototype.hasKnownLength = function() {
384    var hasKnownLength = true;
385  
386    if (this._valuesToMeasure.length) {
387      hasKnownLength = false;
388    }
389  
390    return hasKnownLength;
391  };
392  
393  FormData.prototype.getLength = function(cb) {
394    var knownLength = this._overheadLength + this._valueLength;
395  
396    if (this._streams.length) {
397      knownLength += this._lastBoundary().length;
398    }
399  
400    if (!this._valuesToMeasure.length) {
401      process.nextTick(cb.bind(this, null, knownLength));
402      return;
403    }
404  
405    asynckit.parallel(this._valuesToMeasure, this._lengthRetriever, function(err, values) {
406      if (err) {
407        cb(err);
408        return;
409      }
410  
411      values.forEach(function(length) {
412        knownLength += length;
413      });
414  
415      cb(null, knownLength);
416    });
417  };
418  
419  FormData.prototype.submit = function(params, cb) {
420    var request
421      , options
422      , defaults = {method: 'post'}
423      ;
424  
425    // parse provided url if it's string
426    // or treat it as options object
427    if (typeof params == 'string') {
428  
429      params = parseUrl(params);
430      options = populate({
431        port: params.port,
432        path: params.pathname,
433        host: params.hostname,
434        protocol: params.protocol
435      }, defaults);
436  
437    // use custom params
438    } else {
439  
440      options = populate(params, defaults);
441      // if no port provided use default one
442      if (!options.port) {
443        options.port = options.protocol == 'https:' ? 443 : 80;
444      }
445    }
446  
447    // put that good code in getHeaders to some use
448    options.headers = this.getHeaders(params.headers);
449  
450    // https if specified, fallback to http in any other case
451    if (options.protocol == 'https:') {
452      request = https.request(options);
453    } else {
454      request = http.request(options);
455    }
456  
457    // get content length and fire away
458    this.getLength(function(err, length) {
459      if (err) {
460        this._error(err);
461        return;
462      }
463  
464      // add content length
465      request.setHeader('Content-Length', length);
466  
467      this.pipe(request);
468      if (cb) {
469        var onResponse;
470  
471        var callback = function (error, responce) {
472          request.removeListener('error', callback);
473          request.removeListener('response', onResponse);
474  
475          return cb.call(this, error, responce);
476        };
477  
478        onResponse = callback.bind(this, null);
479  
480        request.on('error', callback);
481        request.on('response', onResponse);
482      }
483    }.bind(this));
484  
485    return request;
486  };
487  
488  FormData.prototype._error = function(err) {
489    if (!this.error) {
490      this.error = err;
491      this.pause();
492      this.emit('error', err);
493    }
494  };
495  
496  FormData.prototype.toString = function () {
497    return '[object FormData]';
498  };