assert jsonData["dataType"]=="hash"

			stats.logExchangedNode(len(indices))

			frontier=[]

			for (j,i) in enumerate(indices):

				(j1,j2)=[HashTree.HASH_LEN*ji for ji in (j,j+1)]

				if localTree.store[i]!=binData[j1:j2]:

					# ie. 0-6 nodes, 7-14 leaves. 2*6+2<15

					if 2*i+2<len(localTree.store): # inner node

						frontier.append(2*i+1)

						frontier.append(2*i+2)

					else:

						blocksToTransfer.append(i-localTree.leafStart) # leaf

						progress.p(i-localTree.leafStart)

			nodeStack.extend(reversed(frontier))

		progress.done()

		size=stats.formatBytes(len(blocksToTransfer)*self._tree.BLOCK_SIZE)

		print(datetime.now(), "{0} to transfer".format(size))

		return blocksToTransfer

	def sendData(self,blocksToTransfer):

		log.info(blocksToTransfer)

		print(datetime.now(), "sending data:")

		progress=Progress(len(blocksToTransfer))

		for k in range(0,len(blocksToTransfer),conf.batchSize.data):

			indices=[]

			blocks=[]

			for j in range(conf.batchSize.data):

				if k+j>=len(blocksToTransfer): break

				blocks.append(block)

				progress.p(k+j)

			if indices: self._sendData(indices,blocks)

		progress.done()

		self._outcoming.writeMsg({"command":"end","action":"push"})

		log.info("closing session...")

		dataFile.close()

	def pullData(self,blocksToTransfer,ignoreLock=False):

		if not ignoreLock:

			try:

				self._lock()

			except LockedException:

				print("The file is locked. Either (a) there's another pull going on (then wait or kill it), or (b) a previous pull ended prematurely and the file is probably corrupt (then repeat pull with -f for force).")

				return

		log.info(blocksToTransfer)

		dataFile=DataFile.open(self._filename, mode="rb+")

		print(datetime.now(), "receiving data:")

		progress=Progress(len(blocksToTransfer))

		for k in range(0,len(blocksToTransfer),conf.batchSize.data):

			indices=blocksToTransfer[k:k+conf.batchSize.data]

import socket

import ssl

import multiprocessing

import logging as log

from hashtree import hashBlock

from netnode import BaseConnection,NetNode

import config as conf

import status

class Connection(BaseConnection):

	def __init__(self,serverSocket,sslContext):

		super().__init__()

		sock, address = serverSocket.accept()

		self._socket=sslContext.wrap_socket(sock,server_side=True)

		log.info('Connected by {0}'.format(address))

		self.createNetworkers()

class Miniserver:

	def __init__(self,filename,treeFile=""):

		self._filename=filename

		self._treeFile=treeFile

		self._ssl=ssl.create_default_context(ssl.Purpose.CLIENT_AUTH,cafile=conf.peers)

		self._ssl.verify_mode=ssl.CERT_REQUIRED

		self._ssl.load_cert_chain(conf.certfile,conf.keyfile)

		self._ss = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

		self._ss.bind(("", conf.port))

		self._ss.listen(1)

	def serve(self):

		p=None

		with self._ss:

			while True:

				connection=Connection(self._ss,self._ssl)

				if p and p.is_alive():

					with connection as c:

						c[0].readMsg()

						c[1].writeMsg({"command":"deny","status":status.locked})

					continue

				p=multiprocessing.Process(target=Server.run,args=(connection,self._filename,self._treeFile))

				p.start()

class Server(NetNode):

	def __init__(self,connection,filename,treeFile=""):

		super().__init__(filename,treeFile)

		(self._incoming,self._outcoming)=connection

		self.BLOCK_SIZE=self._tree.BLOCK_SIZE

	@staticmethod

	def run(connection,*args):

		with connection as c:

			s=Server(c,*args)

			s.serve()

	@property

	def _dataFile(self):

	def serve(self):

		try:

			while self._serveOne(): pass

		except (AssertionError,ConnectionResetError) as e:

			log.warning(e)

	def _serveOne(self):

		jsonData,binData=self._incoming.readMsg()

		if jsonData["command"]=="init":

			if jsonData["blockSize"]!=self.BLOCK_SIZE or jsonData["blockCount"]!=self._tree.leafCount:

				self._outcoming.writeMsg({"command":"deny","status":status.incompatible.parameters})

			if jsonData["version"]<conf.lowestCompatible:

				self._outcoming.writeMsg({"command":"deny","status":status.incompatible.version})

			if jsonData["action"]=="pull" and self.isLocked():

				self._outcoming.writeMsg({"command":"deny","status":status.locked})

			if jsonData["action"]=="push" and not self.isLocked():

				self._lock()

			self._outcoming.writeMsg({"command":"init", "version":conf.version})

		elif jsonData["command"]=="req":

			if jsonData["dataType"]=="data":

			if jsonData.get("action")=="push": self._unlock()

			return False

		else:

			assert False, jsonData["command"]

		return True

	def _requestHash(self,indices):

		log.info("received request for nodes #{0}".format(",".join(str(i) for i in indices)))

		assert all(i<len(self._tree.store) for i in indices)

		hashes=[self._tree.store[i] for i in indices]

		jsonResponse={"command":"send", "index":indices, "dataType":"hash"}

		binResponse=b"".join(hashes)

		return (jsonResponse,binResponse)

	def _requestData(self,index):

		log.info("received request for data block #{0}".format(index))

		jsonResponse={"command":"send", "index":index, "dataType":"data"}

		blocks=[]

		for i in index:

		return (jsonResponse,b"".join(blocks))

	def _receiveData(self,jsonData,binData):

		if not self.isLocked(): self._lock()

		log.info("received data block #{0}: {1}...{2}".format(jsonData["index"],binData[:5],binData[-5:]))

		indices=jsonData["index"]

		for (i,k) in enumerate(indices):

			block=binData[i*self.BLOCK_SIZE:(i+1)*self.BLOCK_SIZE]

			if self._treeFile:

				self._newLeaves[k+self._tree.leafStart]=hashBlock(block)

		return ({"command": "ack", "index": indices},)

	def _finalize(self):

		log.info("closing session...")

		self._dataFile.close()

		if self._treeFile:

			self._updateTree()

		log.info("done")