Implemented PacketReader, renamed Packet{Reader,Writer}Factory in the

protocol component to Protocol{Reader,Writer}Factory.

components/net/sf/briar/protocol/writers/ProtocolWriterFactoryImpl.java

@@ -7,7 +7,7 @@ import net.sf.briar.api.crypto.CryptoComponent;
 import net.sf.briar.api.protocol.writers.AckWriter;
 import net.sf.briar.api.protocol.writers.BatchWriter;
 import net.sf.briar.api.protocol.writers.OfferWriter;
-import net.sf.briar.api.protocol.writers.PacketWriterFactory;
+import net.sf.briar.api.protocol.writers.ProtocolWriterFactory;
 import net.sf.briar.api.protocol.writers.RequestWriter;
 import net.sf.briar.api.protocol.writers.SubscriptionWriter;
 import net.sf.briar.api.protocol.writers.TransportWriter;
@@ -15,13 +15,13 @@ import net.sf.briar.api.serial.WriterFactory;
 
 import com.google.inject.Inject;
 
-class PacketWriterFactoryImpl implements PacketWriterFactory {
+class ProtocolWriterFactoryImpl implements ProtocolWriterFactory {
 
 	private final MessageDigest messageDigest;
 	private final WriterFactory writerFactory;
 
 	@Inject
-	PacketWriterFactoryImpl(CryptoComponent crypto,
+	ProtocolWriterFactoryImpl(CryptoComponent crypto,
 			WriterFactory writerFactory) {
 		messageDigest = crypto.getMessageDigest();
 		this.writerFactory = writerFactory;

components/net/sf/briar/protocol/writers/WritersModule.java

@@ -1,6 +1,6 @@
 package net.sf.briar.protocol.writers;
 
-import net.sf.briar.api.protocol.writers.PacketWriterFactory;
+import net.sf.briar.api.protocol.writers.ProtocolWriterFactory;
 
 import com.google.inject.AbstractModule;
 
@@ -8,6 +8,6 @@ public class WritersModule extends AbstractModule {
 
 	@Override
 	protected void configure() {
-		bind(PacketWriterFactory.class).to(PacketWriterFactoryImpl.class);
+		bind(ProtocolWriterFactory.class).to(ProtocolWriterFactoryImpl.class);
 	}
 }

components/net/sf/briar/transport/ConnectionRecogniserImpl.java

@@ -76,9 +76,8 @@ DatabaseListener {
 		initialised = true;
 	}
 
-	private synchronized byte[] calculateTag(ContactId c,
-			long connectionNumber) {
-		byte[] tag = TagEncoder.encodeTag(transportId, connectionNumber, 0L);
+	private synchronized byte[] calculateTag(ContactId c, long connection) {
+		byte[] tag = TagEncoder.encodeTag(transportId, connection, 0L);
 		Cipher cipher = contactToCipher.get(c);
 		assert cipher != null;
 		try {
@@ -97,25 +96,25 @@ DatabaseListener {
 		if(!initialised) initialise();
 		Bytes b = new Bytes(tag);
 		ContactId contactId = tagToContact.remove(b);
-		Long connectionNumber = tagToConnectionNumber.remove(b);
-		assert (contactId == null) == (connectionNumber == null);
+		Long connection = tagToConnectionNumber.remove(b);
+		assert (contactId == null) == (connection == null);
 		if(contactId == null) return null;
 		// The tag was expected - update and save the connection window
 		ConnectionWindow w = contactToWindow.get(contactId);
 		assert w != null;
-		w.setSeen(connectionNumber);
+		w.setSeen(connection);
 		db.setConnectionWindow(contactId, transportId, w);
 		// Update the set of expected tags
 		Map<Long, Bytes> oldTags = contactToTags.remove(contactId);
 		assert oldTags != null;
-		assert oldTags.containsKey(connectionNumber);
+		assert oldTags.containsKey(connection);
 		Map<Long, Bytes> newTags = new HashMap<Long, Bytes>();
 		for(Long unseen : w.getUnseenConnectionNumbers()) {
 			Bytes expectedTag = oldTags.get(unseen);
 			if(expectedTag == null) {
 				expectedTag = new Bytes(calculateTag(contactId, unseen));
 				tagToContact.put(expectedTag, contactId);
-				tagToConnectionNumber.put(expectedTag, connectionNumber);
+				tagToConnectionNumber.put(expectedTag, connection);
 			}
 			newTags.put(unseen, expectedTag);
 		}

components/net/sf/briar/transport/ConnectionWindowImpl.java

@@ -23,29 +23,29 @@ class ConnectionWindowImpl implements ConnectionWindow {
 		return bitmap;
 	}
 
-	public boolean isSeen(long connectionNumber) {
-		int offset = getOffset(connectionNumber);
+	public boolean isSeen(long connection) {
+		int offset = getOffset(connection);
 		int mask = 0x80000000 >>> offset;
 		return (bitmap & mask) != 0;
 	}
 
-	private int getOffset(long connectionNumber) {
-		if(connectionNumber < 0L) throw new IllegalArgumentException();
-		if(connectionNumber > Constants.MAX_32_BIT_UNSIGNED)
+	private int getOffset(long connection) {
+		if(connection < 0L) throw new IllegalArgumentException();
+		if(connection > Constants.MAX_32_BIT_UNSIGNED)
 			throw new IllegalArgumentException();
-		int offset = (int) (connectionNumber - centre) + 16;
+		int offset = (int) (connection - centre) + 16;
 		if(offset < 0 || offset > 31) throw new IllegalArgumentException();
 		return offset;
 	}
 
-	public void setSeen(long connectionNumber) {
-		int offset = getOffset(connectionNumber);
+	public void setSeen(long connection) {
+		int offset = getOffset(connection);
 		int mask = 0x80000000 >>> offset;
 		if((bitmap & mask) != 0) throw new IllegalArgumentException();
 		bitmap |= mask;
 		// If the new connection number is above the centre, slide the window
-		if(connectionNumber >= centre) {
-			centre = connectionNumber + 1;
+		if(connection >= centre) {
+			centre = connection + 1;
 			bitmap <<= offset - 16 + 1;
 		}
 	}

components/net/sf/briar/transport/PacketReaderImpl.java

@@ -0,0 +1,126 @@
+package net.sf.briar.transport;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+import javax.crypto.Mac;
+
+import net.sf.briar.api.protocol.Ack;
+import net.sf.briar.api.protocol.Batch;
+import net.sf.briar.api.protocol.Offer;
+import net.sf.briar.api.protocol.Request;
+import net.sf.briar.api.protocol.SubscriptionUpdate;
+import net.sf.briar.api.protocol.Tags;
+import net.sf.briar.api.protocol.TransportUpdate;
+import net.sf.briar.api.protocol.writers.ProtocolReaderFactory;
+import net.sf.briar.api.serial.Reader;
+import net.sf.briar.api.serial.ReaderFactory;
+import net.sf.briar.api.transport.PacketReader;
+
+class PacketReaderImpl implements PacketReader {
+
+	private final Reader reader;
+	private final PacketDecrypter decrypter;
+	private final Mac mac;
+	private final int transportId;
+	private final long connection;
+
+	private long packet = 0L;
+	private boolean betweenPackets = true;
+
+	PacketReaderImpl(byte[] firstTag, ReaderFactory readerFactory,
+			ProtocolReaderFactory protocol, PacketDecrypter decrypter, Mac mac,
+			int transportId, long connection) {
+		InputStream in = decrypter.getInputStream();
+		reader = readerFactory.createReader(in);
+		reader.addObjectReader(Tags.ACK, protocol.createAckReader(in));
+		reader.addObjectReader(Tags.BATCH, protocol.createBatchReader(in));
+		reader.addObjectReader(Tags.OFFER, protocol.createOfferReader(in));
+		reader.addObjectReader(Tags.REQUEST, protocol.createRequestReader(in));
+		reader.addObjectReader(Tags.SUBSCRIPTIONS,
+				protocol.createSubscriptionReader(in));
+		reader.addObjectReader(Tags.TRANSPORTS,
+				protocol.createTransportReader(in));
+		this.decrypter = decrypter;
+		this.mac = mac;
+		this.transportId = transportId;
+		this.connection = connection;
+	}
+
+	public boolean eof() throws IOException {
+		return reader.eof();
+	}
+
+	public boolean hasAck() throws IOException {
+		if(betweenPackets) readTag();
+		return reader.hasUserDefined(Tags.ACK);
+	}
+
+	private void readTag() throws IOException {
+		assert betweenPackets;
+		if(packet > Constants.MAX_32_BIT_UNSIGNED)
+			throw new IllegalStateException();
+		byte[] tag = decrypter.readTag();
+		if(!TagDecoder.decodeTag(tag, transportId, connection, packet))
+			throw new IOException();
+		mac.update(tag);
+		packet++;
+		betweenPackets = false;
+	}
+
+	public Ack readAck() throws IOException {
+		if(betweenPackets) readTag();
+		return reader.readUserDefined(Tags.ACK, Ack.class);
+	}
+
+	public boolean hasBatch() throws IOException {
+		if(betweenPackets) readTag();
+		return reader.hasUserDefined(Tags.BATCH);
+	}
+
+	public Batch readBatch() throws IOException {
+		if(betweenPackets) readTag();
+		return reader.readUserDefined(Tags.BATCH, Batch.class);
+	}
+
+	public boolean hasOffer() throws IOException {
+		if(betweenPackets) readTag();
+		return reader.hasUserDefined(Tags.OFFER);
+	}
+
+	public Offer readOffer() throws IOException {
+		if(betweenPackets) readTag();
+		return reader.readUserDefined(Tags.OFFER, Offer.class);
+	}
+
+	public boolean hasRequest() throws IOException {
+		if(betweenPackets) readTag();
+		return reader.hasUserDefined(Tags.REQUEST);
+	}
+
+	public Request readRequest() throws IOException {
+		if(betweenPackets) readTag();
+		return reader.readUserDefined(Tags.REQUEST, Request.class);
+	}
+
+	public boolean hasSubscriptionUpdate() throws IOException {
+		if(betweenPackets) readTag();
+		return reader.hasUserDefined(Tags.SUBSCRIPTIONS);
+	}
+
+	public SubscriptionUpdate readSubscriptionUpdate() throws IOException {
+		if(betweenPackets) readTag();
+		return reader.readUserDefined(Tags.SUBSCRIPTIONS,
+				SubscriptionUpdate.class);
+	}
+
+	public boolean hasTransportUpdate() throws IOException {
+		if(betweenPackets) readTag();
+		return reader.hasUserDefined(Tags.TRANSPORTS);
+	}
+
+	public TransportUpdate readTransportUpdate() throws IOException {
+		if(betweenPackets) readTag();
+		return reader.readUserDefined(Tags.TRANSPORTS, TransportUpdate.class);
+	}
+}

components/net/sf/briar/transport/PacketWriterFactoryImpl.java

@@ -21,9 +21,9 @@ class PacketWriterFactoryImpl implements PacketWriterFactory {
 		this.crypto = crypto;
 	}
 
-	public PacketWriter createPacketWriter(OutputStream out,
-			int transportIdentifier, long connectionNumber, SecretKey macKey,
-			SecretKey tagKey, SecretKey packetKey) {
+	public PacketWriter createPacketWriter(OutputStream out, int transportId,
+			long connection, SecretKey macKey, SecretKey tagKey,
+			SecretKey packetKey) {
 		Mac mac = crypto.getMac();
 		try {
 			mac.init(macKey);
@@ -32,7 +32,7 @@ class PacketWriterFactoryImpl implements PacketWriterFactory {
 		}
 		PacketEncrypter e = new PacketEncrypterImpl(out, crypto.getTagCipher(),
 				crypto.getPacketCipher(), tagKey, packetKey);
-		return new PacketWriterImpl(e, mac, transportIdentifier,
-				connectionNumber);
+		return new PacketWriterImpl(e, mac, transportId,
+				connection);
 	}
 }

components/net/sf/briar/transport/PacketWriterImpl.java

@@ -12,25 +12,25 @@ class PacketWriterImpl extends FilterOutputStream implements PacketWriter {
 
 	private final PacketEncrypter encrypter;
 	private final Mac mac;
-	private final int transportIdentifier;
-	private final long connectionNumber;
+	private final int transportId;
+	private final long connection;
 
-	private long packetNumber = 0L;
+	private long packet = 0L;
 	private boolean betweenPackets = true;
 
-	PacketWriterImpl(PacketEncrypter encrypter, Mac mac,
-			int transportIdentifier, long connectionNumber) {
+	PacketWriterImpl(PacketEncrypter encrypter, Mac mac, int transportId,
+			long connection) {
 		super(encrypter.getOutputStream());
 		this.encrypter = encrypter;
 		this.mac = mac;
-		if(transportIdentifier < 0) throw new IllegalArgumentException();
-		if(transportIdentifier > Constants.MAX_16_BIT_UNSIGNED)
+		if(transportId < 0) throw new IllegalArgumentException();
+		if(transportId > Constants.MAX_16_BIT_UNSIGNED)
 			throw new IllegalArgumentException();
-		this.transportIdentifier = transportIdentifier;
-		if(connectionNumber < 0L) throw new IllegalArgumentException();
-		if(connectionNumber > Constants.MAX_32_BIT_UNSIGNED)
+		this.transportId = transportId;
+		if(connection < 0L) throw new IllegalArgumentException();
+		if(connection > Constants.MAX_32_BIT_UNSIGNED)
 			throw new IllegalArgumentException();
-		this.connectionNumber = connectionNumber;
+		this.connection = connection;
 	}
 
 	public OutputStream getOutputStream() {
@@ -69,14 +69,15 @@ class PacketWriterImpl extends FilterOutputStream implements PacketWriter {
 	}
 
 	private void writeTag() throws IOException {
-		if(packetNumber > Constants.MAX_32_BIT_UNSIGNED)
+		assert betweenPackets;
+		if(packet > Constants.MAX_32_BIT_UNSIGNED)
 			throw new IllegalStateException();
-		byte[] tag = TagEncoder.encodeTag(transportIdentifier, connectionNumber,
-				packetNumber);
+		byte[] tag = TagEncoder.encodeTag(transportId, connection,
+				packet);
 		// Write the tag to the encrypter and start calculating the MAC
 		encrypter.writeTag(tag);
 		mac.update(tag);
-		packetNumber++;
+		packet++;
 		betweenPackets = false;
 	}
 }

components/net/sf/briar/transport/TagDecoder.java

@@ -0,0 +1,33 @@
+package net.sf.briar.transport;
+
+class TagDecoder {
+
+	static boolean decodeTag(byte[] tag, int transportId, long connection,
+			long packet) {
+		if(tag.length != Constants.TAG_BYTES) return false;
+		// First 16 bits must be zero
+		if(readUint16(tag, 0) != 0) return false;
+		// Transport identifier is encoded as an unsigned 16-bit integer
+		if(readUint16(tag, 2) != transportId) return false;
+		// Connection number is encoded as an unsigned 32-bit integer
+		if(readUint32(tag, 4) != connection) return false;
+		// Packet number is encoded as an unsigned 32-bit integer
+		if(readUint32(tag, 8) != packet) return false;
+		// Last 32 bits must be zero
+		if(readUint32(tag, 12) != 0L) return false;
+		return true;
+	}
+
+	// Package access for testing
+	static int readUint16(byte[] b, int offset) {
+		assert b.length >= offset + 2;
+		return ((b[offset] & 0xFF) << 8) | (b[offset + 1] & 0xFF);
+	}
+
+	// Package access for testing
+	static long readUint32(byte[] b, int offset) {
+		assert b.length >= offset + 4;
+		return ((b[offset] & 0xFFL) << 24) | ((b[offset + 1] & 0xFFL) << 16)
+		| ((b[offset + 2] & 0xFFL) << 8) | (b[offset + 3] & 0xFFL);
+	}
+}

components/net/sf/briar/transport/TagEncoder.java

@@ -1,16 +1,16 @@
 package net.sf.briar.transport;
 
-public class TagEncoder {
+class TagEncoder {
 
-	static byte[] encodeTag(int transportIdentifier, long connectionNumber,
-			long packetNumber) {
+	static byte[] encodeTag(int transportId, long connection,
+			long packet) {
 		byte[] tag = new byte[Constants.TAG_BYTES];
 		// Encode the transport identifier as an unsigned 16-bit integer
-		writeUint16(transportIdentifier, tag, 2);
+		writeUint16(transportId, tag, 2);
 		// Encode the connection number as an unsigned 32-bit integer
-		writeUint32(connectionNumber, tag, 4);
+		writeUint32(connection, tag, 4);
 		// Encode the packet number as an unsigned 32-bit integer
-		writeUint32(packetNumber, tag, 8);
+		writeUint32(packet, tag, 8);
 		return tag;
 	}