diff --git a/wifitables/ifstats.py b/wifitables/ifstats.py
new file mode 100644
index 0000000..ae277a9
--- /dev/null
+++ b/wifitables/ifstats.py
@@ -0,0 +1,188 @@
+"""ifstats: get information about a wireless interface."""
+
+import os
+import pipes
+import re
+
+
+class InterfaceStats(object):
+  """InterfaceStats collects statistics from a wireless interface."""
+
+  def __init__(self, system=None, runner=None, interface=None):
+    self.system = system
+    self.run = runner
+    self.interface = interface
+
+  def IwLink(self, devname):
+    """Invoke `iw dev <devname> link` and return its output as a string."""
+    return self.run('iw dev {} link'.format(pipes.quote(devname)))
+
+  def IwScan(self, devname):
+    """Invoke `iw dev <devname> scan` and return its output as a string."""
+    devname_quoted = pipes.quote(devname)
+    text = self.run('iw dev {} scan dump'.format(devname_quoted))
+    if not text:
+      text = self.run('iw dev {} scan'.format(devname_quoted))
+    return text
+
+  def IpAddr(self):
+    """Invoke `ip addr` in one-line mode and return output as a string."""
+    return self.run('ip -o -f inet addr')
+
+  def AirportI(self):
+    """Gather information about the current wireless network from `airport`."""
+    return self.run('airport -I')
+
+  def AirportScan(self):
+    """Gather information about other observable networks from `airport`."""
+    return self.run('airport -s')
+
+  def GatherDarwin(self):
+    """Gather wireless network information on Darwin (Mac OS X)."""
+    return {
+        'airport': self.AirportI(),
+        'airportscan': self.AirportScan(),
+    }
+
+  def GatherLinux(self):
+    """Gather wireless network information on Linux."""
+    outputs = {'ipaddr': self.IpAddr()}
+    if self.interface is not None:
+      outputs.update({
+          'iwlink': self.IwLink(self.interface),
+          'iwscan': self.IwScan(self.interface)
+      })
+      return outputs
+
+    # If no interface was supplied, use the first connected one (like `airport`
+    # does for you automatically.)
+    iw_dev_raw = self.run('iw dev')
+    for line in iw_dev_raw.splitlines():
+      tokens = line.split()
+      if len(tokens) >= 2 and tokens[0] == 'Interface':
+        interface = tokens[1]
+        try:
+          outputs.update({
+              'iwlink': self.IwLink(interface),
+              'iwscan': self.IwScan(interface)
+          })
+          return outputs
+        except ValueError:
+          pass
+
+    raise ValueError('No connected interfaces found.')
+
+  def Gather(self):
+    """Gather all the wireless network information we know how to."""
+    if self.system == 'Darwin':
+      return self.GatherDarwin()
+    elif self.system == 'Linux':
+      return self.GatherLinux()
+    else:
+      raise OSError('System {} unsupported for InterfaceStats'.format(
+          self.system))
+
+def ParseIwLink(text):
+  ol = text.splitlines()
+
+  # BSSID is in the first line, in an idiosyncratic format.
+  # sample: Connected to d8:c7:c8:d7:72:30 (on wlan0)
+  m = re.search(r'(\w{2}:){5}\w{2}', ol[0])
+  if m:
+    result = {'BSSID': m.group(0)}
+  else:
+    raise ValueError('dev was not connected.')
+
+  for line in ol[1:]:
+    try:
+      key, value = line.split(':', 1)
+      result[key.strip()] = value.strip()
+    except ValueError:
+      continue
+
+  return result
+
+def ParseIpAddr(text):
+  ol = text.splitlines()
+  result = {}
+  for line in ol:
+    _, interface, _, addr, _ = line.split(None, 4)
+    result[interface] = addr
+
+  return result
+
+
+def ParseAirportI(text):
+  result = {}
+  for line in text.splitlines():
+    try:
+      key, value = [cell.strip() for cell in line.split(':', 1)]
+      if key in ['agrCtlRSSI', 'agrCtlNoise']:
+        result[key] = int(value)
+      else:
+        result[key] = value
+    except ValueError:
+      continue
+
+  return result
+
+def ParseAirportScan(text):
+  # This is a simple fixed-width format.
+  header = ['SSID', 'BSSID', 'RSSI', 'CHANNEL', 'HT', 'CC',
+            'SECURITY (auth/unicast/group)']
+  result = []
+
+  chre = re.compile(r'\d+(?:,\+|-\d+)?')
+  for line in text.splitlines():
+    ssid, bssid, rssi, channel, ht, cc, security = (
+        [cell.strip() for cell in (line[:32], line[33:50], line[51:55],
+                                   line[56:63], line[64:66], line[67:69],
+                                   line[70:])])
+
+    # the scan sometimes includes comment lines. assume that anything that has
+    # a valid channel isn't a comment line.
+    if chre.match(channel):
+      result += [[ssid, bssid, int(rssi), channel, ht, cc, security]]
+
+  return [header] + result
+
+def Parse(system, cache):
+  if system == 'Darwin':
+    return {
+        'link': ParseAirportI(cache.get('airport')),
+        'scan': ParseAirportScan(cache.get('airportscan'))
+    }
+  elif system == 'Linux':
+    return {
+        'link': ParseIwLink(cache.get('iwlink')),
+        'addr': ParseIpAddr(cache.get('ipaddr'))
+    }
+  else:
+    raise OSError('Attempt to parse cache from '
+                  'unrecognized system {}'.format(system))
+
+def Restore(report_dir):
+  """Restore an InterfaceStats cache from data on the filesystem."""
+  cache = {}
+
+  apath = os.path.join(report_dir, 'airport')
+  if os.path.exists(apath):
+    system = 'Darwin'
+    names = ['airport', 'airportscan']
+  else:
+    iwpath = os.path.join(report_dir, 'iwlink')
+    if os.path.exists(iwpath):
+      system = 'Linux'
+      names = ['ipaddr', 'iwlink', 'iwscan']
+    else:
+      raise IOError('Could not open report in {}'.format(report_dir))
+
+  for name in names:
+    try:
+      with open(os.path.join(report_dir, name)) as infile:
+        cache[name] = infile.read()
+    except IOError:
+      cache[name] = ''
+
+  return system, cache
+
diff --git a/wifitables/iperf.py b/wifitables/iperf.py
new file mode 100644
index 0000000..efe6781
--- /dev/null
+++ b/wifitables/iperf.py
@@ -0,0 +1,116 @@
+"""iperf: run a series of iperf tests over a wireless network."""
+
+import os
+import pipes
+import re
+import sys
+
+DEVNULL = open(os.devnull, 'wb')
+
+
+class Iperf(object):
+  """Iperf collects `iperf` measurements across a wireless network."""
+
+  def __init__(self, runner=None, bind=None):
+    self.run = runner
+    self.bind = bind
+    self.cache = {}
+
+  def Ping(self, host):
+    line = 'ping -c 1 {}'.format(pipes.quote(host))
+    return self.run(line).return_code
+
+  def _Iperf(self, host, udp=False, bandwidth=20):
+    """Run iperf against host and return string containing stdout from run."""
+    line = 'iperf -c {}'
+    args = [host]
+    if udp:
+      line += ' -u -b {}'
+      args += [str(bandwidth * 1000000)]
+    if self.bind:
+      line += ' -B {}'
+      args += [self.bind]
+
+    return self.run(line.format(*[pipes.quote(arg) for arg in args]))
+
+  def IperfTCP(self, host='127.0.0.1'):
+    return self._Iperf(host)
+
+  def IperfUDP(self, host='127.0.0.1', bandwidth=20):
+    return self._Iperf(host, udp=True, bandwidth=bandwidth)
+
+  def RunTestSeries(self, host):
+    """RunTestSeries runs iperf tests and returns their results.
+
+    Args:
+      host: string containing the hostname to run tests against
+    Returns:
+      a list of files; each file contains output for one test
+    """
+    outputs = {}
+    status = self.Ping(host)
+    if not status:
+      it = self.IperfTCP(host)
+      outputs['iperf'] = it
+
+      # Empirically about 1.25x more packets make it through in UDP than TCP.
+      # Try to saturate the channel by sending a bit more than that over UDP.
+      bandwidth = ParseIperfTCP(it).get('bandwidth', 0.01)
+      outputs['iperfu'] = self.IperfUDP(host, bandwidth=bandwidth * 1.5)
+    else:
+      print >> sys.stderr, ('Could not ping destination host {0}; '
+                            'skipping performance tests').format(host)
+
+    return outputs
+
+def _ParseIperf(text, udp=False):
+  """Parse summary line written by an `iperf` run into a Python dict."""
+  pattern = (r'\[(.{3})\]\s+(?P<interval>.*?sec)\s+'
+             r'(?P<transfer>.*?Bytes|bits)'
+             r'\s+(?P<bandwidth>.*?/sec)')
+  if udp:
+    pattern += r'\s+(?P<jitter>.*?s)\s+(?P<datagrams>.*)'
+
+  iperf_re = re.compile(pattern)
+
+  for line in text.splitlines():
+    match = iperf_re.match(line)
+    if match:
+      iperf = match.groupdict()
+      bval, bunit = iperf['bandwidth'].split()
+      iperf['bandwidth'] = float(bval)
+      iperf['bandwidth_unit'] = bunit
+
+      tval, tunit = iperf['transfer'].split()
+      iperf['transfer'] = float(tval)
+      iperf['transfer_unit'] = tunit
+      return iperf
+
+  return {}
+
+
+def ParseIperfTCP(text):
+  # sample line: [  4]  0.0-10.0 sec   245 MBytes   206 Mbits/sec
+  return _ParseIperf(text)
+
+
+def ParseIperfUDP(text):
+  # pylint: disable=line-too-long
+  # sample line: [  5]  0.0-10.0 sec  1.25 MBytes  1.05 Mbits/sec   0.593 ms    0/  893 (0%)
+  return _ParseIperf(text, udp=True)
+
+
+def Restore(report_dir):
+  """Restores an `Iperf` cache from data on the filesystem."""
+  cache = {}
+  for name in ['iperf', 'iperfu']:
+    ipath = os.path.join(report_dir, name)
+    if os.path.exists(ipath):
+      with open(ipath) as infile:
+        cache[name] = infile.read()
+    else:
+      cache[name] = ''
+
+  return cache
+
+
diff --git a/wifitables/report.py b/wifitables/report.py
index 8ee0fac..67719b2 100755
--- a/wifitables/report.py
+++ b/wifitables/report.py
@@ -7,6 +7,9 @@
 import os
 import re
 import sys
+
+import ifstats
+import iperf
 import options
 
 optspec = """
@@ -80,44 +83,6 @@
   return counter.most_common()[0][0], phy / alltimes
 
 
-def ParseIperf(out, udp=False):
-  """Parse output written by an `iperf` run into structured data."""
-  pattern = (r'\[(.{3})\]\s+(?P<interval>.*?sec)\s+(?P<transfer>.*?Bytes|bits)'
-             r'\s+(?P<bandwidth>.*?/sec)')
-  if udp:
-    pattern += r'\s+(?P<jitter>.*?s)\s+(?P<datagrams>.*)'
-
-  iperf_re = re.compile(pattern)
-
-  for line in out.splitlines():
-    match = iperf_re.match(line)
-    if match:
-      iperf = match.groupdict()
-      bval, bunit = iperf['bandwidth'].split()
-      iperf['bandwidth'] = float(bval)
-      iperf['bandwidth_unit'] = bunit
-
-      tval, tunit = iperf['transfer'].split()
-      iperf['transfer'] = float(tval)
-      iperf['transfer_unit'] = tunit
-      return iperf
-
-  return {}
-
-
-def ParseIperfTCP(out):
-  """ParseIperfTCP parses the output of TCP `iperf` runs."""
-  # sample line: [  4]  0.0-10.0 sec   245 MBytes   206 Mbits/sec
-  return ParseIperf(out)
-
-
-def ParseIperfUDP(out):
-  """ParseIperfUDP parses the output of UDP `iperf` runs."""
-  # pylint: disable=line-too-long
-  # sample line: [  5]  0.0-10.0 sec  1.25 MBytes  1.05 Mbits/sec   0.593 ms    0/  893 (0%)
-  return ParseIperf(out, udp=True)
-
-
 def Channel(text_channel):
   """Given a text channel spec like 149,+1 return the central freq and width."""
   LoadChannels()
@@ -131,77 +96,6 @@
     return channels[int(text_channel)], 20
 
 
-def ParseAirportI(output):
-  """Parse output of `airport -I` and return it as a dictionary."""
-  result = {}
-  for line in output.splitlines():
-    try:
-      key, value = [cell.strip() for cell in line.split(':', 1)]
-      if key in ['agrCtlRSSI', 'agrCtlNoise']:
-        result[key] = int(value)
-      else:
-        result[key] = value
-    except ValueError:
-      continue
-
-  return result
-
-
-def ParseAirportScan(output):
-  """Parse output of `airport -s` and return it as a dictionary."""
-  # This is a simple fixed-width format.
-  header = ['SSID', 'BSSID', 'RSSI', 'CHANNEL', 'HT', 'CC',
-            'SECURITY (auth/unicast/group)']
-  result = []
-
-  chre = re.compile(r'\d+(?:,\+|-\d+)?')
-  for line in output.splitlines():
-    ssid, bssid, rssi, channel, ht, cc, security = (
-        [cell.strip() for cell in (line[:32], line[33:50], line[51:55],
-                                   line[56:63], line[64:66], line[67:69],
-                                   line[70:])])
-
-    # the scan sometimes includes comment lines. assume that anything that has
-    # a valid channel isn't a comment line.
-    if chre.match(channel):
-      result += [[ssid, bssid, int(rssi), channel, ht, cc, security]]
-
-  return [header] + result
-
-
-def ParseIwLink(output):
-  """Parse output of `iw dev <devname> link` and return it as a dictionary."""
-  ol = output.splitlines()
-
-  # BSSID is in the first line, in an idiosyncratic format.
-  # sample: Connected to d8:c7:c8:d7:72:30 (on wlan0)
-  m = re.search(r'(\w{2}:){5}\w{2}', ol[0])
-  if m:
-    result = {'BSSID': m.group(0)}
-  else:
-    raise ValueError('dev was not connected.')
-
-  for line in ol[1:]:
-    try:
-      key, value = line.split(':', 1)
-      result[key.strip()] = value.strip()
-    except ValueError:
-      continue
-
-  return result
-
-
-def ParseIpAddr(output):
-  """Parse output of one-line `ip addr` and return it as a dictionary."""
-  ol = output.splitlines()
-  result = {}
-  for line in ol:
-    _, interface, _, addr, _ = line.split(None, 4)
-    result[interface] = addr
-
-  return result
-
-
 def Overlap(c1, w1, c2, w2):
   """Return True if two WiFi channels overlap, or False otherwise."""
   # TODO(willangley): replace with code from Waveguide
@@ -219,35 +113,28 @@
   _, _, steps = os.path.basename(report_dir).split('-')
   line = [int(steps)]
 
-  # Reports generated on Mac have 'airport'
-  apath = os.path.join(report_dir, 'airport')
-  if os.path.isfile(apath):
-    with open(apath) as ai:
-      airport = ParseAirportI(ai.read())
-
+  system, cache = ifstats.Restore(report_dir)
+  result = ifstats.Parse(system, cache)
+  if system == 'Darwin':
+    airport = result.get('link')
     channel, width = Channel(airport['channel'])
     shared = 0
     overlap = 0
 
-    cpath = os.path.join(report_dir, 'airportscan')
-    if os.path.exists(cpath):
-      with open(cpath) as ac:
-        for row in ParseAirportScan(ac.read())[1:]:
-          oc, ow = Channel(row[3])
-          if channel == oc and width == ow:
-            shared += 1
-          if Overlap(channel, width, oc, ow):
-            overlap += 1
+    scan = result.get('scan')
+    if len(scan) > 1:
+      for row in scan[1:]:
+        oc, ow = Channel(row[3])
+        if channel == oc and width == ow:
+          shared += 1
+        if Overlap(channel, width, oc, ow):
+          overlap += 1
 
     rssi = airport['agrCtlRSSI']
     noise = airport['agrCtlNoise']
     line += [channel, width, rssi, noise, shared, overlap - shared]
-
-  else:
-    # assume the report was generated on Linux.
-    with open(os.path.join(report_dir, 'iwlink')) as il:
-      iwlink = ParseIwLink(il.read())
-
+  elif system == 'Linux':
+    iwlink = result.get('link')
     signal = int(iwlink.get('signal', '0 dBm').split()[0])
     channel = int(iwlink.get('freq'))
     width = 20
@@ -259,24 +146,18 @@
     line += [channel, width, signal, None, None, None]
 
   mpath = os.path.join(report_dir, 'mcs')
-  if os.path.isfile(mpath):
-    with open(os.path.join(report_dir, 'mcs')) as mf:
+  if os.path.exists(mpath):
+    with open(mpath) as mf:
       line += ParseMCSFile(mf, width)
   else:
     line += [None, None]
 
   # If the initial ping test fails, we won't collect performance information.
   # deal with this gracefully.
-  for fn, infile in [(ParseIperfTCP, 'iperf'),
-                     (ParseIperfUDP, 'iperfu')]:
-    ipath = os.path.join(report_dir, infile)
-    if not os.path.isfile(ipath):
-      line += [None, None]
-      continue
-
-    with open(ipath) as ip:
-      perf = fn(ip.read())
-      line += [perf.get('bandwidth'), perf.get('bandwidth_unit')]
+  ips = iperf.Restore(report_dir)
+  for perf in [iperf.ParseIperfTCP(ips.get('iperf', '')),
+               iperf.ParseIperfUDP(ips.get('iperfu', ''))]:
+    line += [perf.get('bandwidth'), perf.get('bandwidth_unit')]
 
   return line
 
diff --git a/wifitables/report_test.py b/wifitables/report_test.py
index b324fe4..6ccb832 100644
--- a/wifitables/report_test.py
+++ b/wifitables/report_test.py
@@ -2,6 +2,7 @@
 
 import os
 
+import ifstats
 import report
 from wvtest import *  # pylint: disable=wildcard-import
 
@@ -14,11 +15,11 @@
 
   idx = (0, 20, 800)
   print 'Testing MCS rate in file', idx
-  WVPASSEQ(report.nrates[idx], 6.5 )
+  WVPASSEQ(report.nrates[idx], 6.5)
 
   idx = (25, 40, 400)
   print 'Testing computed MCS rate', idx
-  WVPASSEQ(report.nrates[idx], 120 )
+  WVPASSEQ(report.nrates[idx], 120)
 
   print
   report.LoadChannels()
@@ -37,16 +38,15 @@
 def TVBoxReport():
   rpt = 'testdata/wifi-1424739295.41-0010'
   print 'Checking IP address'
-  with open(os.path.join(rpt, 'ipaddr')) as ip:
-    addrmap = report.ParseIpAddr(ip.read())
-    WVPASSEQ(addrmap.get('lo'), '127.0.0.1/32')
-    WVPASSEQ(addrmap.get('wcli0'), '192.168.1.222/24')
+  system, cache = ifstats.Restore(rpt)
+  addrmap = ifstats.ParseIpAddr(cache['ipaddr'])
+  WVPASSEQ(addrmap.get('lo'), '127.0.0.1/32')
+  WVPASSEQ(addrmap.get('wcli0'), '192.168.1.222/24')
 
   print 'Checking for link information'
-  with open(os.path.join(rpt, 'iwlink')) as iw:
-    data = report.ParseIwLink(iw.read())
-    WVPASSEQ(data.get('SSID'), 'GSAFNS1441P0208_TestWifi')
-    WVPASSEQ(data.get('BSSID'), 'f4:f5:e8:80:f3:d0')
+  data = ifstats.ParseIwLink(cache['iwlink'])
+  WVPASSEQ(data.get('SSID'), 'GSAFNS1441P0208_TestWifi')
+  WVPASSEQ(data.get('BSSID'), 'f4:f5:e8:80:f3:d0')
 
   line = report.ReportLine(rpt)
   print ('Checking report. Implemented measures: steps, channel, width, rssi, '
diff --git a/wifitables/sample.py b/wifitables/sample.py
index 6ff88cf..89cfe2f 100755
--- a/wifitables/sample.py
+++ b/wifitables/sample.py
@@ -2,221 +2,62 @@
 
 """sample: measure wireless performance and write a report to the filesystem."""
 
-import multiprocessing
+import atexit
+import functools
 import os
 import platform
-import re
-import shutil
 import subprocess
 import sys
-import tempfile
 import time
 
+from fabric.api import env, execute, local, run
+from fabric.network import disconnect_all
+
+import ifstats
+import iperf
 import options
-import report
+import tcpdump
 
 optspec = """
 sample [options...]
 --
+B,bind=         interface IP to bind during iperf runs
 d,destination=  host to run tests against [192.168.1.143]
 s,steps=        number of steps test was run from [10]
 j,journal=      append to journal tracking a series of test runs
-i,interface=    wireless interface to use for outgoing connections [{0}]
-m,monitor=      wireless monitor interface to use [{1}]
+i,interface=    wireless interface to use for outgoing connections
+m,monitor=      wireless monitor interface to use
+r,remote=       remote host to run tests on
 """
 
-DEVNULL = open(os.devnull, 'wb')
-
-
-def Ping(host):
-  code = subprocess.call(['ping', '-c', '1', host], stdout=DEVNULL,
-                         stderr=DEVNULL)
-  return code
-
-
-def Iperf(host, path, udp=False, bandwidth=20, bind=None):
-  """Run iperf against host and report results."""
-  line = ['iperf', '-c', host]
-  name = 'iperf'
-
-  if udp:
-    line += ['-u', '-b', str(bandwidth * 1000000)]
-    name += 'u'
-  if bind:
-    line += ['-B', bind]
-
-  out = open(os.path.join(path, name), 'w+')
-  subprocess.check_call(line, stdout=out)
-  return out
-
-
-def MCSBackground(tcpdump, out):
-  """Continually extract wireless MCS from a running `tcpdump` process.
-
-  This function will not return as long as tcpdump is running. You probably want
-  to run it in a background activity using multiprocessing.
-
-  Args:
-    tcpdump: a tcpdump process that's monitoring a wireless interface
-                  and writing textual output to its stdout stream.
-    out:          Python file-like object to write MCS information to.
-  """
-  mcs = re.compile(r'MCS (\d+)')
-  x = 0
-
-  for row in iter(tcpdump.stdout.readline, b''):
-    x += 1
-    match = mcs.search(row)
-    if match:
-      print >> out, '%2d ' % int(match.group(1)),
-    else:
-      print >> out, ' . ',
-
-    if x % 25 == 0:
-      print >> out
-
-
-def MCS(bssid, interface, path):
-  """Runs tcpdump in the background to gather wireless MCS."""
-  print 'Please enter password for `sudo` if prompted.'
-  subprocess.call(['sudo', '-v'])
-
-  out = open(os.path.join(path, 'mcs'), 'w+')
-  err = open(os.path.join(path, 'mcserr'), 'w+')
-
-  filt = ('(not subtype beacon and not subtype ack) and '
-          '(wlan addr1 {0} or wlan addr2 {0} or wlan addr3 {0})'.format(
-              bssid, bssid, bssid))
-
-  sudo_tcpdump = subprocess.Popen(['sudo', 'tcpdump', '-Z', os.getlogin(),
-                                   '-Ilnei', interface, filt],
-                                  stdout=subprocess.PIPE, stderr=err)
-  proc = multiprocessing.Process(target=MCSBackground, args=(sudo_tcpdump, out))
-  proc.start()
-
-  return sudo_tcpdump, out, err
-
-
-def IwLink(devname, path):
-  out = open(os.path.join(path, 'iwlink'), 'w+')
-  subprocess.check_call(['iw', 'dev', devname, 'link'], stdout=out)
-  return out
-
-
-def IwScan(devname, path):
-  out = open(os.path.join(path, 'iwscan'), 'w+')
-  subprocess.check_call(['iw', 'dev', devname, 'scan', 'dump'], stdout=out)
-  if os.fstat(out.file.fileno()).st_size: return out
-
-  subprocess.check_call(['iw', 'dev', devname, 'scan'], stdout=out)
-  return out
-
-
-def IpAddr(path):
-  out = open(os.path.join(path, 'ipaddr'), 'w+')
-  subprocess.check_call(['ip', '-o', '-f', 'inet', 'addr'], stdout=out)
-  return out
-
-
-def AirportI(path):
-  """Gather information about the current wireless network from `airport`."""
-  out = open(os.path.join(path, 'airport'), 'w+')
-  subprocess.check_call(['airport', '-I'], stdout=out)
-  return out
-
-
-def AirportScan(path):
-  """Gather information about other observable networks from `airport`."""
-  out = open(os.path.join(path, 'airportscan'), 'w+')
-  subprocess.check_call(['airport', '-s'], stdout=out)
-  return out
-
 
 def main():
   system = platform.system()
   defaults = {
       # on a modern MacBook, en0 is the AirPort and can monitor and send at once
-      'Darwin': ['en0', 'en0'],
-      # on Linux, separate client and monitor interfaces are needed.
-      # these defaults are for a TV box, other platforms will be different.
-      'Linux': ['wcli0', ''],
+      'Darwin': {
+          'monitor': 'en0'
+      },
+      # on Linux, separate client and monitor interfaces are needed; and the
+      # monitor interface must be manually created
+      'Linux': {
+          'monitor': 'moni0'  # from the `iw` documentation
+      },
   }
 
+  o = options.Options(optspec)
+  (opt, _, extra) = o.parse(sys.argv[1:])
+  if extra:
+    o.fatal('did not understand supplied extra arguments.')
+
   if not defaults.get(system):
     raise OSError('Running on unsupported system {0}; '
                   'supported systems are {1}'.format(system,
                                                      ' '.join(defaults.keys())))
 
-  o = options.Options(optspec.format(*defaults[system]))
-  (opt, _, extra) = o.parse(sys.argv[1:])
-  if extra:
-    o.fatal('did not understand supplied extra arguments.')
-
   # Pick the report name before we run it, so it can be consistent across
   # multiple systems.
   report_name = 'wifi-{}-{:04}'.format(time.time(), opt.steps)
-  report_dir = tempfile.mkdtemp(prefix='wifi')
-
-  # we run diagnostics, write their output to files, and gather the files into
-  # a report that we present at the end of the run.
-  outputs = []
-  addr = ''
-
-  if system == 'Darwin':
-    ai = AirportI(report_dir)
-    ai.seek(0)
-    bssid = report.ParseAirportI(ai.read())['BSSID']
-    outputs += [ai, AirportScan(report_dir)]
-  elif system == 'Linux':
-    # It's really likely we're running on a device with more than one interface.
-    # Be sure we're using the one that we're trying to test.
-    ip = IpAddr(report_dir)
-    ip.seek(0)
-    addrmap = report.ParseIpAddr(ip.read())
-    addr = addrmap.get(opt.interface)
-    if not addr:
-      raise ValueError('Interface {0} does not have an IPv4 address.'.format(
-          opt.interface))
-
-    # because ip addr usually includes a subnet mask, which will prevent iperf
-    # from binding to the address
-    mask = addr.find('/')
-    if mask > -1:
-      addr = addr[:mask]
-
-    il = IwLink(opt.interface, report_dir)
-    il.seek(0)
-    bssid = report.ParseIwLink(il.read())['BSSID']
-
-    ic = IwScan(opt.interface, report_dir)
-    outputs += [ip, il, ic]
-  else:
-    raise OSError('This script requires Mac OS X or Linux.')
-
-  if opt.monitor:
-    sudo_tcpdump, mcs_out, mcs_err = MCS(bssid, opt.monitor, report_dir)
-    print 'Gathering tcpdump in background as', sudo_tcpdump.pid
-    outputs += [mcs_out, mcs_err]
-
-  status = Ping(opt.destination)
-  if not status:
-    it = Iperf(opt.destination, report_dir, bind=addr)
-
-    # Empirically about 1.25x more packets make it through in UDP than TCP.
-    # Try to saturate the channel by sending a bit more than that over UDP.
-    it.seek(0)
-    it_iperf = report.ParseIperfTCP(it.read())
-
-    bandwidth = it_iperf.get('bandwidth', 0.01)
-    outputs += [it, Iperf(opt.destination, report_dir, udp=True,
-                          bandwidth=bandwidth * 1.5,
-                          bind=addr)]
-  else:
-    print >> sys.stderr, ('Could not ping destination host {0}; '
-                          'skipping performance tests').format(opt.destination)
-
-  if opt.monitor:
-    subprocess.check_call(['sudo', 'kill', str(sudo_tcpdump.pid)])
 
   if opt.journal:
     with open(opt.journal, 'a') as journal:
@@ -225,10 +66,75 @@
   else:
     dest_dir = report_name
 
-  shutil.move(report_dir, dest_dir)
-  print 'Report written to', dest_dir
-  for name in (o.name for o in outputs):
-    print '*', os.path.basename(name)
+  print 'Report being written to', dest_dir
+  if not os.path.exists(dest_dir):
+    os.makedirs(dest_dir)
+
+  # we run diagnostics, write their output to files, and gather the files into
+  # a report that we present at the end of the run.
+  #
+  # entries collects Entry objects that have not been written to disk yet.
+  execute_args = {}
+  if opt.remote:
+    # update Fabric env for embedded systems
+    env.update({
+        'key_filename': os.path.expanduser('~/.ssh/bruno-sshkey'),
+        'user': 'root',
+        'shell': 'sh -l -c',
+    })
+    execute_args['host'] = opt.remote
+
+    ifsystem = 'Linux'
+    ifrun = run
+
+    atexit.register(disconnect_all)
+  else:
+    ifsystem = system
+    ifrun = functools.partial(local, capture=True)
+
+  ifs = ifstats.InterfaceStats(system=ifsystem,
+                               runner=ifrun,
+                               interface=opt.interface)
+
+  # since we're only executing over one host, ignore the return from `execute`
+  # that says which host it was for now.
+  cache = execute(ifs.Gather, **execute_args).values()[0]
+  results = ifstats.Parse(ifsystem, cache)
+
+  bssid = results['link']['BSSID']
+  addr = results.get('addr', {}).get(opt.interface, '')
+
+  # because ip addr usually includes a subnet mask, which will prevent iperf
+  # from binding to the address
+  mask = addr.find('/')
+  if mask > -1:
+    addr = addr[:mask]
+
+  if opt.monitor:
+    sudo_tcpdump, mcs_out, mcs_err = tcpdump.MCS(bssid, opt.monitor, dest_dir)
+    print 'Gathering tcpdump in background as', sudo_tcpdump.pid
+
+  ips = iperf.Iperf(runner=ifrun, bind=addr)
+  env.warn_only = True  # `iperf` returns 56 if it can't reach the server,
+                        # or 57 if it doesn't receive a final report from it
+                        # on Linux; don't abort in these cases
+  cache.update(
+      execute(ips.RunTestSeries, opt.destination, **execute_args).values()[0]
+  )
+
+  if opt.monitor:
+    subprocess.check_call(['sudo', 'kill', str(sudo_tcpdump.pid)])
+    for stream in [mcs_out, mcs_err]:
+      stream.flush()
+      stream.close()
+
+  if opt.journal:
+    with open(opt.journal, 'a') as journal:
+      print >> journal, report_name
+
+  for name, value in cache.items():
+    with open(os.path.join(dest_dir, name), 'w+b') as outfile:
+      outfile.write(value)
 
 
 if __name__ == '__main__':
diff --git a/wifitables/tcpdump.py b/wifitables/tcpdump.py
new file mode 100644
index 0000000..b1e9b3d
--- /dev/null
+++ b/wifitables/tcpdump.py
@@ -0,0 +1,58 @@
+"""tcpdump: helper module that gathers wireless network MCS using tcpdump."""
+
+import multiprocessing
+import os
+import re
+import subprocess
+
+
+def MCSBackground(tcpdump, out):
+  """Continually extract wireless MCS from `tcpdump` output.
+
+  If tcpdump is actively capturing packets, this function will not return as
+  long as tcpdump is running. You probably want to run it in a background
+  activity using multiprocessing.
+
+  Args:
+    tcpdump: a tcpdump process that's writing text output with Radiotap headers
+             to its stdout stream.
+    out:     Python file-like object to write MCS information to.
+  """
+  mcsre = re.compile(r'MCS (\d+)')
+  x = 0
+
+  for row in iter(tcpdump.stdout.readline, b''):
+    x += 1
+    match = mcsre.search(row)
+    if match:
+      mcs = int(match.group(1))
+      out.write('{:02} '.format(mcs))
+    else:
+      out.write(' . ')
+
+    if x % 25 == 0:
+      out.write('\n')
+
+
+def MCS(bssid, interface, report_dir=''):
+  """Runs tcpdump in the background to gather wireless MCS."""
+  print 'Please enter password for `sudo` if prompted.'
+  subprocess.call(['sudo', '-v'])
+
+  out = open(os.path.join(report_dir, 'mcs'), 'w+b')
+  err = open(os.path.join(report_dir, 'mcserr'), 'w+b')
+
+  filt = ('(not subtype beacon and not subtype ack) and '
+          '(wlan addr1 {0} or wlan addr2 {0} or wlan addr3 {0})'.format(
+              bssid, bssid, bssid))
+
+  sudo_tcpdump = subprocess.Popen(['sudo', 'tcpdump', '-Z', os.getlogin(),
+                                   '-Ilnei', interface, filt],
+                                  stdout=subprocess.PIPE,
+                                  stderr=err)
+  proc = multiprocessing.Process(target=MCSBackground,
+                                 args=(sudo_tcpdump, out))
+  proc.start()
+
+  return sudo_tcpdump, out, err
+