def post(self, connection):
		# Add to queue (POST).
		if 'file' not in connection.post[1] or 'port' not in connection.post[0] or 'action' not in connection.post[0]:
			self.reply(connection, 400)
			return False
		port = connection.post[0]['port'][0]
		action = connection.post[0]['action'][0]
		if port not in ports or not ports[port]:
			log('port not found: %s' % port)
			self.reply(connection, 404)
			return False
		post = connection.post[1].pop('file')
		def cb(success, ret):
			self.reply(connection, 200 if success else 400, '' if ret is None else ret.encode('utf8'), 'text/plain;charset=utf8')
			os.unlink(post[0]);
			connection.socket.close()
		if action == 'queue_add':
			ports[port].call('queue_add_file', [connection.data['role'], post[0], post[1]], {}, cb)
		elif action == 'audio_add':
			ports[port].call('audio_add_file', [connection.data['role'], post[0], post[1]], {}, cb)
		elif action == 'import':
			ports[port].call('import_file', [connection.data['role'], post[0], post[1]], {}, cb)
		else:
			os.unlink(post[0]);
			self.reply(connection, 400)
			return False
		return True

	def _call(self, name, a, ka): # {{{
		wake = (yield)
		#log('other: %s %s %s' % (name, repr(a), repr(ka)))
		if 'machine' in ka:
			machine = ka.pop('machine')
		else:
			machine = None
		if machine not in machines:
			if len(machines) == 1:
				machine = tuple(machines.keys())[0]
			else:
				options = [m for m in machines if machines[m].port is not None]
				if len(options) == 1:
					machine = options[0]
				else:
					log('No active machine')
					return ('error', 'No active machine')
		if name.endswith('_POST'):
			log('refusing to call function only meant for POST')
			return ('error', 'Invalid function name')
		def reply(success, ret):
			if success:
				wake(ret)
			else:
				log('machine errors')
				wake(('error', ret))
				#disable(machine, 'machine replied with error to wake up')
		machines[machine].call(name, (self.socket.data['role'],) + tuple(a), ka, reply)
		return (yield)

		def process_done():
			data = p.stdout.read()
			if data:
				log('Data from completion callback: %s' % repr(data))
				return True
			log('Callback for job completion done; return: %s' % repr(p.wait()))
			return False

		def boot_machine_error():
			log('error during machine detection on port %s.' % port)
			websocketd.remove_timeout(timeout_handle[0])
			machine.close()
			ports[port] = None
			broadcast(None, 'port_state', port, 0)
			return False

def disable(role, port): # {{{
	if port not in ports:
		log('not disabling nonexistent port %s' % port)
		return
	p = ports[port]
	if p is None:
		log('not disabling inactive port %s' % port)
		return
	if not isinstance(p, Port):
		# Detecting or similar; cancel operation.
		p()
		return
	if p.detecting:
		p.die()
		return
	# Forget the printer.  First tell the printer to die
	p.die()
	ports[port] = None
	if p:
		def done(success, ret):
			websocketd.remove_read(p.input_handle)
			try:
				p.process.kill()
			except OSError:
				pass
			try:
				p.process.communicate()
			except:
				pass
			p.process = None
		p.call('die', (role, 'disabled by user',), {}, done)
	if p not in (None, False):
		broadcast(None, 'del_printer', port)
	broadcast(None, 'port_state', port, 0)

	def upload(self, port, board): # {{{
		wake = (yield)
		assert self.socket.data['role'] in ('benjamin', 'admin')
		assert port in ports
		if ports[port]:
			disable(ports[port], 'disabled for upload')
		def cancel():
			# Waking the generator kills the process.
			wake('Aborted')
		ports[port] = cancel
		command = self._get_command(board, port)
		data = ['']
		log('Flashing firmware: ' + ' '.join(command))
		broadcast(None, 'port_state', port, 3)
		process = subprocess.Popen(command, stdin = subprocess.PIPE, stdout = subprocess.PIPE, stderr = subprocess.STDOUT, close_fds = True)
		def output():
			d = ''
			try:
				d = process.stdout.read().decode('utf-8')
			except:
				data[0] += '\nError writing %s firmware: ' % board + traceback.format_exc()
				log(repr(data[0]))
				wake(data[0])
				return False
			if d != '':
				#broadcast(None, 'message', port, '\n'.join(data[0].split('\n')[-4:]))
				data[0] += d
				return True
			wake(data[0])
			return False
		def error():
			data[0] += '\nError writing %s firmware: ' % board
			log(repr(data[0]))
			wake(data[0])
			return False
		fl = fcntl.fcntl(process.stdout.fileno(), fcntl.F_GETFL)
		fcntl.fcntl(process.stdout.fileno(), fcntl.F_SETFL, fl | os.O_NONBLOCK)
		websocketd.add_read(process.stdout, output, error)
		broadcast(None, 'uploading', port, 'uploading firmware for %s' % board)
		#broadcast(None, 'message', port, '')
		d = (yield)
		try:
			process.kill()	# In case it wasn't dead yet.
		except:
			pass
		try:
			process.communicate()	# Clean up.
		except:
			pass
		broadcast(None, 'uploading', port, None)
		#broadcast(None, 'message', port, '')
		broadcast(None, 'port_state', port, 0)
		ports[port] = None
		if autodetect:
			websocketd.call(None, detect, port)
		if d:
			return 'firmware upload for %s: ' % board + d
		else:
			return 'firmware for %s successfully uploaded' % board

def remove_port(port): # {{{
	log('removing port %s' % port)
	if port not in ports:
		return
	if ports[port]:
		ports[port].make_orphan()
	del ports[port]
	broadcast(None, 'del_port', port)

def remove_port(port): # {{{
	log('removing port %s' % port)
	if port not in ports:
		return
	if ports[port]:
		disable(ports[port], 'port is removed')
	del ports[port]
	broadcast(None, 'del_port', port)

	def remove_port(cls, port): # {{{
		log('removing port %s' % port)
		if port not in ports:
			return
		if ports[port]:
			# Close serial port, in case it still exists.
			cls._disable('admin', port)
		del ports[port]
		cls._broadcast(None, 'del_port', port)

	def detect(cls, port): # {{{
		resumeinfo = [(yield), None]
		log('detecting printer on %s' % port)
		if port not in ports or ports[port] != None:
			log('port is not in detectable state')
			return
		ports[port] = False
		c = websocketd.call(resumeinfo, detect, port)
		while c(): c.args = (yield websocketd.WAIT)

	def die(self, reason = 'at request'): # {{{
		log('{} died {}.'.format(self.name, reason))
		self.process.kill()
		try:
			self.process.communicate()
		except:
			pass
		for t in range(3):
			for w in self.waiters[t]:
				self.waiters[t][w](False, 'Printer {} died {}'.format(self.name, reason))

	def make_orphan(self): # {{{
		if ports[self.port]:
			self.call('disconnect', ['admin'], {}, lambda cd, arg: None)
		# If there already is an orphan with the same uuid, kill the old orphan.
		for o in [x for x in orphans if orphans[x].uuid == self.uuid]:
			# This for loop always runs 0 or 1 times, never more.
			log('killing duplicate orphan')
			orphans[o].call('die', ('admin', 'replaced by connection with same uuid',), {}, lambda success, ret: None)
			del orphans[o]
		orphans[self.run_id] = self
		broadcast(None, 'del_printer', self.port)

		def get_vars(success, vars):
			if not success:
				log('failed to get vars')
				return
			# The child has opened the port now; close our handle.
			if detectport is not None:
				log('Driver started; closing server port')
				detectport.close()
			self.uuid = vars['uuid']
			# Copy settings from orphan with the same run_id, then kill the orphan.
			if self.run_id in orphans and orphans[self.run_id].uuid == self.uuid:
				orphans[self.run_id].call('export_settings', ('admin',), {}, get_settings)

	def add_port(cls, port): # {{{
		wake = (yield)
		if port in ports:
			log('already existing port %s cannot be added' % port)
			return
		if re.match(config['blacklist'], port) or re.match(config['add-blacklist'], port):
			#log('skipping blacklisted port %s' % port)
			return
		ports[port] = None
		cls._broadcast(None, 'new_port', port);
		if autodetect:
			return (yield from cls._generator_call(wake, cls.detect, port))

def add_port(port): # {{{
	if port in ports:
		log('already existing port %s cannot be added' % port)
		return
	if re.match(config['blacklist'], port) or re.match(config['add-blacklist'], port):
		#log('skipping blacklisted port %s' % port)
		return
	ports[port] = None
	broadcast(None, 'new_port', port)
	broadcast(None, 'port_state', port, 0)
	if autodetect:
		detect(port, 'admin')

def add_port(port): # {{{
	if port in ports:
		log('already existing port %s cannot be added' % port)
		return
	if not re.match(config['whitelist'], port) or re.match(config['blacklist'], port) or re.match(config['add-blacklist'], port):
		#log('skipping blacklisted or non-whitelisted port %s' % port)
		return
	ports[port] = None
	broadcast(None, 'new_port', port, upload_options(port))
	broadcast(None, 'port_state', port, 0)
	if autodetect:
		websocketd.call(None, detect, port)

	def call(self, name, args, kargs, cb): # {{{
		data = json.dumps([self.next_mid, name, args, kargs]) + '\n'
		#log('calling %s on %d' % (repr(data), self.process.stdin.fileno()))
		try:
			self.process.stdin.write(data)
		except:
			log('killing printer handle because of IOError')
			#traceback.print_exc()
			cb(False, None)
			Connection._disable('admin', self.port)
			return
		self.waiters[0][self.next_mid] = cb
		self.next_mid += 1

	def add_port(cls, port): # {{{
		resumeinfo = [(yield), None]
		if port in ports:
			log('already existing port %s cannot be added' % port)
			return
		if re.match(config['blacklist'], port) or re.match(config['add-blacklist'], port):
			#log('skipping blacklisted port %s' % port)
			return
		ports[port] = None
		cls._broadcast(None, 'new_port', port);
		if autodetect:
			c = websocketd.call(resumeinfo, cls.detect, port)
			while c(): c.args = (yield websocketd.WAIT)

		def get_settings(success, settings):
			if not success:
				log('failed to get settings')
				return
			self.call('import_settings', ['admin', settings], {}, lambda success, ret: None)
			GLib.source_remove(orphans[self.run_id].input_handle)
			orphans[self.run_id].call('die', ('admin', 'replaced by new connection',), {}, lambda success, ret: None)
			try:
				orphans[self.run_id].process.kill()
				orphans[self.run_id].process.communicate()
			except OSError:
				pass
			del orphans[self.run_id]

		def get_vars(success, vars, cb = None):
			if not success:
				log('failed to get vars')
				return
			if self.uuid is None:
				log('new uuid:' + repr(vars['uuid']))
				self.uuid = vars['uuid']
			else:
				assert self.uuid == vars['uuid']
			self.detecting = False
			self.call('send_machine', ['admin', None], {}, lambda success, data: broadcast(None, 'port_state', port, 2))
			if cb is not None:
				cb()