appium-mac2-driver 4.5.0 → 4.6.0

package/node_modules/spdy-transport/lib/spdy-transport/protocol/http2/parser.js

@@ -0,0 +1,578 @@
+'use strict'
+
+var parser = exports
+
+var transport = require('../../../spdy-transport')
+var base = transport.protocol.base
+var utils = base.utils
+var constants = require('./').constants
+
+var assert = require('assert')
+var util = require('util')
+
+function Parser (options) {
+  base.Parser.call(this, options)
+
+  this.isServer = options.isServer
+
+  this.waiting = constants.PREFACE_SIZE
+  this.state = 'preface'
+  this.pendingHeader = null
+
+  // Header Block queue
+  this._lastHeaderBlock = null
+  this.maxFrameSize = constants.INITIAL_MAX_FRAME_SIZE
+  this.maxHeaderListSize = constants.DEFAULT_MAX_HEADER_LIST_SIZE
+}
+util.inherits(Parser, base.Parser)
+
+parser.create = function create (options) {
+  return new Parser(options)
+}
+
+Parser.prototype.setMaxFrameSize = function setMaxFrameSize (size) {
+  this.maxFrameSize = size
+}
+
+Parser.prototype.setMaxHeaderListSize = function setMaxHeaderListSize (size) {
+  this.maxHeaderListSize = size
+}
+
+// Only for testing
+Parser.prototype.skipPreface = function skipPreface () {
+  // Just some number bigger than 3.1, doesn't really matter for HTTP2
+  this.setVersion(4)
+
+  // Parse frame header!
+  this.state = 'frame-head'
+  this.waiting = constants.FRAME_HEADER_SIZE
+}
+
+Parser.prototype.execute = function execute (buffer, callback) {
+  if (this.state === 'preface') { return this.onPreface(buffer, callback) }
+
+  if (this.state === 'frame-head') {
+    return this.onFrameHead(buffer, callback)
+  }
+
+  assert(this.state === 'frame-body' && this.pendingHeader !== null)
+
+  var self = this
+  var header = this.pendingHeader
+  this.pendingHeader = null
+
+  this.onFrameBody(header, buffer, function (err, frame) {
+    if (err) {
+      return callback(err)
+    }
+
+    self.state = 'frame-head'
+    self.partial = false
+    self.waiting = constants.FRAME_HEADER_SIZE
+    callback(null, frame)
+  })
+}
+
+Parser.prototype.executePartial = function executePartial (buffer, callback) {
+  var header = this.pendingHeader
+
+  assert.strictEqual(header.flags & constants.flags.PADDED, 0)
+
+  if (this.window) { this.window.recv.update(-buffer.size) }
+
+  callback(null, {
+    type: 'DATA',
+    id: header.id,
+
+    // Partial DATA can't be FIN
+    fin: false,
+    data: buffer.take(buffer.size)
+  })
+}
+
+Parser.prototype.onPreface = function onPreface (buffer, callback) {
+  if (buffer.take(buffer.size).toString() !== constants.PREFACE) {
+    return callback(this.error(constants.error.PROTOCOL_ERROR,
+      'Invalid preface'))
+  }
+
+  this.skipPreface()
+  callback(null, null)
+}
+
+Parser.prototype.onFrameHead = function onFrameHead (buffer, callback) {
+  var header = {
+    length: buffer.readUInt24BE(),
+    control: true,
+    type: buffer.readUInt8(),
+    flags: buffer.readUInt8(),
+    id: buffer.readUInt32BE() & 0x7fffffff
+  }
+
+  if (header.length > this.maxFrameSize) {
+    return callback(this.error(constants.error.FRAME_SIZE_ERROR,
+      'Frame length OOB'))
+  }
+
+  header.control = header.type !== constants.frameType.DATA
+
+  this.state = 'frame-body'
+  this.pendingHeader = header
+  this.waiting = header.length
+  this.partial = !header.control
+
+  // TODO(indutny): eventually support partial padded DATA
+  if (this.partial) {
+    this.partial = (header.flags & constants.flags.PADDED) === 0
+  }
+
+  callback(null, null)
+}
+
+Parser.prototype.onFrameBody = function onFrameBody (header, buffer, callback) {
+  var frameType = constants.frameType
+
+  if (header.type === frameType.DATA) {
+    this.onDataFrame(header, buffer, callback)
+  } else if (header.type === frameType.HEADERS) {
+    this.onHeadersFrame(header, buffer, callback)
+  } else if (header.type === frameType.CONTINUATION) {
+    this.onContinuationFrame(header, buffer, callback)
+  } else if (header.type === frameType.WINDOW_UPDATE) {
+    this.onWindowUpdateFrame(header, buffer, callback)
+  } else if (header.type === frameType.RST_STREAM) {
+    this.onRSTFrame(header, buffer, callback)
+  } else if (header.type === frameType.SETTINGS) {
+    this.onSettingsFrame(header, buffer, callback)
+  } else if (header.type === frameType.PUSH_PROMISE) {
+    this.onPushPromiseFrame(header, buffer, callback)
+  } else if (header.type === frameType.PING) {
+    this.onPingFrame(header, buffer, callback)
+  } else if (header.type === frameType.GOAWAY) {
+    this.onGoawayFrame(header, buffer, callback)
+  } else if (header.type === frameType.PRIORITY) {
+    this.onPriorityFrame(header, buffer, callback)
+  } else if (header.type === frameType.X_FORWARDED_FOR) {
+    this.onXForwardedFrame(header, buffer, callback)
+  } else {
+    this.onUnknownFrame(header, buffer, callback)
+  }
+}
+
+Parser.prototype.onUnknownFrame = function onUnknownFrame (header, buffer, callback) {
+  if (this._lastHeaderBlock !== null) {
+    callback(this.error(constants.error.PROTOCOL_ERROR,
+      'Received unknown frame in the middle of a header block'))
+    return
+  }
+  callback(null, { type: 'unknown: ' + header.type })
+}
+
+Parser.prototype.unpadData = function unpadData (header, body, callback) {
+  var isPadded = (header.flags & constants.flags.PADDED) !== 0
+
+  if (!isPadded) { return callback(null, body) }
+
+  if (!body.has(1)) {
+    return callback(this.error(constants.error.FRAME_SIZE_ERROR,
+      'Not enough space for padding'))
+  }
+
+  var pad = body.readUInt8()
+  if (!body.has(pad)) {
+    return callback(this.error(constants.error.PROTOCOL_ERROR,
+      'Invalid padding size'))
+  }
+
+  var contents = body.clone(body.size - pad)
+  body.skip(body.size)
+  callback(null, contents)
+}
+
+Parser.prototype.onDataFrame = function onDataFrame (header, body, callback) {
+  var isEndStream = (header.flags & constants.flags.END_STREAM) !== 0
+
+  if (header.id === 0) {
+    return callback(this.error(constants.error.PROTOCOL_ERROR,
+      'Received DATA frame with stream=0'))
+  }
+
+  // Count received bytes
+  if (this.window) {
+    this.window.recv.update(-body.size)
+  }
+
+  this.unpadData(header, body, function (err, data) {
+    if (err) {
+      return callback(err)
+    }
+
+    callback(null, {
+      type: 'DATA',
+      id: header.id,
+      fin: isEndStream,
+      data: data.take(data.size)
+    })
+  })
+}
+
+Parser.prototype.initHeaderBlock = function initHeaderBlock (header,
+  frame,
+  block,
+  callback) {
+  if (this._lastHeaderBlock) {
+    return callback(this.error(constants.error.PROTOCOL_ERROR,
+      'Duplicate Stream ID'))
+  }
+
+  this._lastHeaderBlock = {
+    id: header.id,
+    frame: frame,
+    queue: [],
+    size: 0
+  }
+
+  this.queueHeaderBlock(header, block, callback)
+}
+
+Parser.prototype.queueHeaderBlock = function queueHeaderBlock (header,
+  block,
+  callback) {
+  var self = this
+  var item = this._lastHeaderBlock
+  if (!this._lastHeaderBlock || item.id !== header.id) {
+    return callback(this.error(constants.error.PROTOCOL_ERROR,
+      'No matching stream for continuation'))
+  }
+
+  var fin = (header.flags & constants.flags.END_HEADERS) !== 0
+
+  var chunks = block.toChunks()
+  for (var i = 0; i < chunks.length; i++) {
+    var chunk = chunks[i]
+    item.queue.push(chunk)
+    item.size += chunk.length
+  }
+
+  if (item.size >= self.maxHeaderListSize) {
+    return callback(this.error(constants.error.PROTOCOL_ERROR,
+      'Compressed header list is too large'))
+  }
+
+  if (!fin) { return callback(null, null) }
+  this._lastHeaderBlock = null
+
+  this.decompress.write(item.queue, function (err, chunks) {
+    if (err) {
+      return callback(self.error(constants.error.COMPRESSION_ERROR,
+        err.message))
+    }
+
+    var headers = {}
+    var size = 0
+    for (var i = 0; i < chunks.length; i++) {
+      var header = chunks[i]
+
+      size += header.name.length + header.value.length + 32
+      if (size >= self.maxHeaderListSize) {
+        return callback(self.error(constants.error.PROTOCOL_ERROR,
+          'Header list is too large'))
+      }
+
+      if (/[A-Z]/.test(header.name)) {
+        return callback(self.error(constants.error.PROTOCOL_ERROR,
+          'Header name must be lowercase'))
+      }
+
+      utils.addHeaderLine(header.name, header.value, headers)
+    }
+
+    item.frame.headers = headers
+    item.frame.path = headers[':path']
+
+    callback(null, item.frame)
+  })
+}
+
+Parser.prototype.onHeadersFrame = function onHeadersFrame (header,
+  body,
+  callback) {
+  var self = this
+
+  if (header.id === 0) {
+    return callback(this.error(constants.error.PROTOCOL_ERROR,
+      'Invalid stream id for HEADERS'))
+  }
+
+  this.unpadData(header, body, function (err, data) {
+    if (err) { return callback(err) }
+
+    var isPriority = (header.flags & constants.flags.PRIORITY) !== 0
+    if (!data.has(isPriority ? 5 : 0)) {
+      return callback(self.error(constants.error.FRAME_SIZE_ERROR,
+        'Not enough data for HEADERS'))
+    }
+
+    var exclusive = false
+    var dependency = 0
+    var weight = constants.DEFAULT_WEIGHT
+    if (isPriority) {
+      dependency = data.readUInt32BE()
+      exclusive = (dependency & 0x80000000) !== 0
+      dependency &= 0x7fffffff
+
+      // Weight's range is [1, 256]
+      weight = data.readUInt8() + 1
+    }
+
+    if (dependency === header.id) {
+      return callback(self.error(constants.error.PROTOCOL_ERROR,
+        'Stream can\'t dependend on itself'))
+    }
+
+    var streamInfo = {
+      type: 'HEADERS',
+      id: header.id,
+      priority: {
+        parent: dependency,
+        exclusive: exclusive,
+        weight: weight
+      },
+      fin: (header.flags & constants.flags.END_STREAM) !== 0,
+      writable: true,
+      headers: null,
+      path: null
+    }
+
+    self.initHeaderBlock(header, streamInfo, data, callback)
+  })
+}
+
+Parser.prototype.onContinuationFrame = function onContinuationFrame (header,
+  body,
+  callback) {
+  this.queueHeaderBlock(header, body, callback)
+}
+
+Parser.prototype.onRSTFrame = function onRSTFrame (header, body, callback) {
+  if (body.size !== 4) {
+    return callback(this.error(constants.error.FRAME_SIZE_ERROR,
+      'RST_STREAM length not 4'))
+  }
+
+  if (header.id === 0) {
+    return callback(this.error(constants.error.PROTOCOL_ERROR,
+      'Invalid stream id for RST_STREAM'))
+  }
+
+  callback(null, {
+    type: 'RST',
+    id: header.id,
+    code: constants.errorByCode[body.readUInt32BE()]
+  })
+}
+
+Parser.prototype._validateSettings = function _validateSettings (settings) {
+  if (settings['enable_push'] !== undefined &&
+      settings['enable_push'] !== 0 &&
+      settings['enable_push'] !== 1) {
+    return this.error(constants.error.PROTOCOL_ERROR,
+      'SETTINGS_ENABLE_PUSH must be 0 or 1')
+  }
+
+  if (settings['initial_window_size'] !== undefined &&
+      (settings['initial_window_size'] > constants.MAX_INITIAL_WINDOW_SIZE ||
+       settings['initial_window_size'] < 0)) {
+    return this.error(constants.error.FLOW_CONTROL_ERROR,
+      'SETTINGS_INITIAL_WINDOW_SIZE is OOB')
+  }
+
+  if (settings['max_frame_size'] !== undefined &&
+      (settings['max_frame_size'] > constants.ABSOLUTE_MAX_FRAME_SIZE ||
+       settings['max_frame_size'] < constants.INITIAL_MAX_FRAME_SIZE)) {
+    return this.error(constants.error.PROTOCOL_ERROR,
+      'SETTINGS_MAX_FRAME_SIZE is OOB')
+  }
+
+  return undefined
+}
+
+Parser.prototype.onSettingsFrame = function onSettingsFrame (header,
+  body,
+  callback) {
+  if (header.id !== 0) {
+    return callback(this.error(constants.error.PROTOCOL_ERROR,
+      'Invalid stream id for SETTINGS'))
+  }
+
+  var isAck = (header.flags & constants.flags.ACK) !== 0
+  if (isAck && body.size !== 0) {
+    return callback(this.error(constants.error.FRAME_SIZE_ERROR,
+      'SETTINGS with ACK and non-zero length'))
+  }
+
+  if (isAck) {
+    return callback(null, { type: 'ACK_SETTINGS' })
+  }
+
+  if (body.size % 6 !== 0) {
+    return callback(this.error(constants.error.FRAME_SIZE_ERROR,
+      'SETTINGS length not multiple of 6'))
+  }
+
+  var settings = {}
+  while (!body.isEmpty()) {
+    var id = body.readUInt16BE()
+    var value = body.readUInt32BE()
+    var name = constants.settingsIndex[id]
+
+    if (name) {
+      settings[name] = value
+    }
+  }
+
+  var err = this._validateSettings(settings)
+  if (err !== undefined) {
+    return callback(err)
+  }
+
+  callback(null, {
+    type: 'SETTINGS',
+    settings: settings
+  })
+}
+
+Parser.prototype.onPushPromiseFrame = function onPushPromiseFrame (header,
+  body,
+  callback) {
+  if (header.id === 0) {
+    return callback(this.error(constants.error.PROTOCOL_ERROR,
+      'Invalid stream id for PUSH_PROMISE'))
+  }
+
+  var self = this
+  this.unpadData(header, body, function (err, data) {
+    if (err) {
+      return callback(err)
+    }
+
+    if (!data.has(4)) {
+      return callback(self.error(constants.error.FRAME_SIZE_ERROR,
+        'PUSH_PROMISE length less than 4'))
+    }
+
+    var streamInfo = {
+      type: 'PUSH_PROMISE',
+      id: header.id,
+      fin: false,
+      promisedId: data.readUInt32BE() & 0x7fffffff,
+      headers: null,
+      path: null
+    }
+
+    self.initHeaderBlock(header, streamInfo, data, callback)
+  })
+}
+
+Parser.prototype.onPingFrame = function onPingFrame (header, body, callback) {
+  if (body.size !== 8) {
+    return callback(this.error(constants.error.FRAME_SIZE_ERROR,
+      'PING length != 8'))
+  }
+
+  if (header.id !== 0) {
+    return callback(this.error(constants.error.PROTOCOL_ERROR,
+      'Invalid stream id for PING'))
+  }
+
+  var ack = (header.flags & constants.flags.ACK) !== 0
+  callback(null, { type: 'PING', opaque: body.take(body.size), ack: ack })
+}
+
+Parser.prototype.onGoawayFrame = function onGoawayFrame (header,
+  body,
+  callback) {
+  if (!body.has(8)) {
+    return callback(this.error(constants.error.FRAME_SIZE_ERROR,
+      'GOAWAY length < 8'))
+  }
+
+  if (header.id !== 0) {
+    return callback(this.error(constants.error.PROTOCOL_ERROR,
+      'Invalid stream id for GOAWAY'))
+  }
+
+  var frame = {
+    type: 'GOAWAY',
+    lastId: body.readUInt32BE(),
+    code: constants.goawayByCode[body.readUInt32BE()]
+  }
+
+  if (body.size !== 0) { frame.debug = body.take(body.size) }
+
+  callback(null, frame)
+}
+
+Parser.prototype.onPriorityFrame = function onPriorityFrame (header,
+  body,
+  callback) {
+  if (body.size !== 5) {
+    return callback(this.error(constants.error.FRAME_SIZE_ERROR,
+      'PRIORITY length != 5'))
+  }
+
+  if (header.id === 0) {
+    return callback(this.error(constants.error.PROTOCOL_ERROR,
+      'Invalid stream id for PRIORITY'))
+  }
+
+  var dependency = body.readUInt32BE()
+
+  // Again the range is from 1 to 256
+  var weight = body.readUInt8() + 1
+
+  if (dependency === header.id) {
+    return callback(this.error(constants.error.PROTOCOL_ERROR,
+      'Stream can\'t dependend on itself'))
+  }
+
+  callback(null, {
+    type: 'PRIORITY',
+    id: header.id,
+    priority: {
+      exclusive: (dependency & 0x80000000) !== 0,
+      parent: dependency & 0x7fffffff,
+      weight: weight
+    }
+  })
+}
+
+Parser.prototype.onWindowUpdateFrame = function onWindowUpdateFrame (header,
+  body,
+  callback) {
+  if (body.size !== 4) {
+    return callback(this.error(constants.error.FRAME_SIZE_ERROR,
+      'WINDOW_UPDATE length != 4'))
+  }
+
+  var delta = body.readInt32BE()
+  if (delta === 0) {
+    return callback(this.error(constants.error.PROTOCOL_ERROR,
+      'WINDOW_UPDATE delta == 0'))
+  }
+
+  callback(null, {
+    type: 'WINDOW_UPDATE',
+    id: header.id,
+    delta: delta
+  })
+}
+
+Parser.prototype.onXForwardedFrame = function onXForwardedFrame (header,
+  body,
+  callback) {
+  callback(null, {
+    type: 'X_FORWARDED_FOR',
+    host: body.take(body.size).toString()
+  })
+}

package/node_modules/spdy-transport/lib/spdy-transport/protocol/spdy/constants.js

@@ -0,0 +1,146 @@
+'use strict'
+
+var transport = require('../../../spdy-transport')
+var base = transport.protocol.base
+
+exports.FRAME_HEADER_SIZE = 8
+
+exports.PING_OPAQUE_SIZE = 4
+
+exports.MAX_CONCURRENT_STREAMS = Infinity
+exports.DEFAULT_MAX_HEADER_LIST_SIZE = Infinity
+
+exports.DEFAULT_WEIGHT = 16
+
+exports.frameType = {
+  SYN_STREAM: 1,
+  SYN_REPLY: 2,
+  RST_STREAM: 3,
+  SETTINGS: 4,
+  PING: 6,
+  GOAWAY: 7,
+  HEADERS: 8,
+  WINDOW_UPDATE: 9,
+
+  // Custom
+  X_FORWARDED_FOR: 0xf000
+}
+
+exports.flags = {
+  FLAG_FIN: 0x01,
+  FLAG_COMPRESSED: 0x02,
+  FLAG_UNIDIRECTIONAL: 0x02
+}
+
+exports.error = {
+  PROTOCOL_ERROR: 1,
+  INVALID_STREAM: 2,
+  REFUSED_STREAM: 3,
+  UNSUPPORTED_VERSION: 4,
+  CANCEL: 5,
+  INTERNAL_ERROR: 6,
+  FLOW_CONTROL_ERROR: 7,
+  STREAM_IN_USE: 8,
+  // STREAM_ALREADY_CLOSED: 9
+  STREAM_CLOSED: 9,
+  INVALID_CREDENTIALS: 10,
+  FRAME_TOO_LARGE: 11
+}
+exports.errorByCode = base.utils.reverse(exports.error)
+
+exports.settings = {
+  FLAG_SETTINGS_PERSIST_VALUE: 1,
+  FLAG_SETTINGS_PERSISTED: 2,
+
+  SETTINGS_UPLOAD_BANDWIDTH: 1,
+  SETTINGS_DOWNLOAD_BANDWIDTH: 2,
+  SETTINGS_ROUND_TRIP_TIME: 3,
+  SETTINGS_MAX_CONCURRENT_STREAMS: 4,
+  SETTINGS_CURRENT_CWND: 5,
+  SETTINGS_DOWNLOAD_RETRANS_RATE: 6,
+  SETTINGS_INITIAL_WINDOW_SIZE: 7,
+  SETTINGS_CLIENT_CERTIFICATE_VECTOR_SIZE: 8
+}
+
+exports.settingsIndex = [
+  null,
+
+  'upload_bandwidth',
+  'download_bandwidth',
+  'round_trip_time',
+  'max_concurrent_streams',
+  'current_cwnd',
+  'download_retrans_rate',
+  'initial_window_size',
+  'client_certificate_vector_size'
+]
+
+exports.DEFAULT_WINDOW = 64 * 1024
+exports.MAX_INITIAL_WINDOW_SIZE = 2147483647
+
+exports.goaway = {
+  OK: 0,
+  PROTOCOL_ERROR: 1,
+  INTERNAL_ERROR: 2
+}
+exports.goawayByCode = base.utils.reverse(exports.goaway)
+
+exports.statusReason = {
+  100: 'Continue',
+  101: 'Switching Protocols',
+  102: 'Processing', // RFC 2518, obsoleted by RFC 4918
+  200: 'OK',
+  201: 'Created',
+  202: 'Accepted',
+  203: 'Non-Authoritative Information',
+  204: 'No Content',
+  205: 'Reset Content',
+  206: 'Partial Content',
+  207: 'Multi-Status', // RFC 4918
+  300: 'Multiple Choices',
+  301: 'Moved Permanently',
+  302: 'Moved Temporarily',
+  303: 'See Other',
+  304: 'Not Modified',
+  305: 'Use Proxy',
+  307: 'Temporary Redirect',
+  308: 'Permanent Redirect', // RFC 7238
+  400: 'Bad Request',
+  401: 'Unauthorized',
+  402: 'Payment Required',
+  403: 'Forbidden',
+  404: 'Not Found',
+  405: 'Method Not Allowed',
+  406: 'Not Acceptable',
+  407: 'Proxy Authentication Required',
+  408: 'Request Time-out',
+  409: 'Conflict',
+  410: 'Gone',
+  411: 'Length Required',
+  412: 'Precondition Failed',
+  413: 'Request Entity Too Large',
+  414: 'Request-URI Too Large',
+  415: 'Unsupported Media Type',
+  416: 'Requested Range Not Satisfiable',
+  417: 'Expectation Failed',
+  418: 'I\'m a teapot', // RFC 2324
+  422: 'Unprocessable Entity', // RFC 4918
+  423: 'Locked', // RFC 4918
+  424: 'Failed Dependency', // RFC 4918
+  425: 'Unordered Collection', // RFC 4918
+  426: 'Upgrade Required', // RFC 2817
+  428: 'Precondition Required', // RFC 6585
+  429: 'Too Many Requests', // RFC 6585
+  431: 'Request Header Fields Too Large', // RFC 6585
+  500: 'Internal Server Error',
+  501: 'Not Implemented',
+  502: 'Bad Gateway',
+  503: 'Service Unavailable',
+  504: 'Gateway Time-out',
+  505: 'HTTP Version Not Supported',
+  506: 'Variant Also Negotiates', // RFC 2295
+  507: 'Insufficient Storage', // RFC 4918
+  509: 'Bandwidth Limit Exceeded',
+  510: 'Not Extended', // RFC 2774
+  511: 'Network Authentication Required' // RFC 6585
+}