Merge branch 'release/1.1.2'

pom.xml

@@ -2,7 +2,7 @@
 	<modelVersion>4.0.0</modelVersion>
 	<groupId>org.cryptomator</groupId>
 	<artifactId>cryptofs</artifactId>
-	<version>1.1.1</version>
+	<version>1.1.2</version>
 	<name>Cryptomator Crypto Filesystem</name>
 	<description>This library provides the Java filesystem provider used by Cryptomator.</description>
 	<url>https://github.com/cryptomator/cryptofs</url>

src/main/java/org/cryptomator/cryptofs/DirectoryIdLoader.java

@@ -20,7 +20,11 @@ public DirectoryIdLoader() {
 	@Override
 	public String load(Path dirFilePath) throws IOException {
 		if (Files.exists(dirFilePath)) {
-			return new String(Files.readAllBytes(dirFilePath), StandardCharsets.UTF_8);
+			byte[] bytes = Files.readAllBytes(dirFilePath);
+			if (bytes.length == 0) {
+				throw new IOException("Invalid, empty directory file: " + dirFilePath);
+			}
+			return new String(bytes, StandardCharsets.UTF_8);
 		} else {
 			return UUID.randomUUID().toString();
 		}

src/main/java/org/cryptomator/cryptofs/EffectiveOpenOptions.java

@@ -159,9 +159,11 @@ private boolean isSupported(OpenOption option) {
 		return StandardOpenOption.class.isInstance(option);
 	}
 
+	// TODO do not add write if filesystem is in readonly mode
 	public Set<OpenOption> createOpenOptionsForEncryptedFile() {
 		Set<OpenOption> result = new HashSet<>(options);
 		result.add(READ); // also needed during write
+		result.add(WRITE); // maybe needed when opening writable channel afterwards
 		result.remove(APPEND);
 		return result;
 	}

src/main/java/org/cryptomator/cryptofs/FinallyUtil.java

@@ -1,8 +1,9 @@
 package org.cryptomator.cryptofs;
 
-import static java.util.Arrays.asList;
-
+import java.util.Arrays;
 import java.util.Iterator;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
 
 import javax.inject.Inject;
 
@@ -13,14 +14,18 @@ class FinallyUtil {
 	public FinallyUtil() {
 	}
 
-	@SuppressWarnings({"rawtypes", "unchecked"})
+	@SuppressWarnings({"unchecked"})
 	public <E extends Exception> void guaranteeInvocationOf(RunnableThrowingException<? extends E>... tasks) throws E {
-		guaranteeInvocationOf((Iterator) asList(tasks).iterator());
+		guaranteeInvocationOf(Arrays.stream(tasks));
 	}
 
-	@SuppressWarnings({"rawtypes", "unchecked"})
 	public <E extends Exception> void guaranteeInvocationOf(Iterable<RunnableThrowingException<? extends E>> tasks) throws E {
-		guaranteeInvocationOf((Iterator) tasks.iterator());
+		guaranteeInvocationOf(StreamSupport.stream(tasks.spliterator(), false));
+	}
+
+	@SuppressWarnings({"unchecked"})
+	public <E extends Exception> void guaranteeInvocationOf(Stream<RunnableThrowingException<? extends E>> tasks) throws E {
+		guaranteeInvocationOf(tasks.map(t -> (RunnableThrowingException<E>) t).iterator());
 	}
 
 	@SuppressWarnings("unchecked")

src/test/java/org/cryptomator/cryptofs/DirectoryIdLoaderTest.java

@@ -0,0 +1,90 @@
+package org.cryptomator.cryptofs;
+
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.CoreMatchers.notNullValue;
+import static org.junit.Assert.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.SeekableByteChannel;
+import java.nio.file.FileSystem;
+import java.nio.file.Path;
+import java.nio.file.spi.FileSystemProvider;
+
+import org.cryptomator.cryptofs.mocks.SeekableByteChannelMock;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+public class DirectoryIdLoaderTest {
+
+	@Rule
+	public ExpectedException thrown = ExpectedException.none();
+
+	private FileSystemProvider provider = mock(FileSystemProvider.class);
+	private FileSystem fileSystem = mock(FileSystem.class);
+	private Path dirFilePath = mock(Path.class);
+	private Path otherDirFilePath = mock(Path.class);
+
+	private DirectoryIdLoader inTest = new DirectoryIdLoader();
+
+	@Before
+	public void setup() {
+		when(dirFilePath.getFileSystem()).thenReturn(fileSystem);
+		when(otherDirFilePath.getFileSystem()).thenReturn(fileSystem);
+		when(fileSystem.provider()).thenReturn(provider);
+	}
+
+	@Test
+	public void testDirectoryIdsForTwoNonExistingFilesDiffer() throws IOException {
+		doThrow(new IOException()).when(provider).checkAccess(dirFilePath);
+		doThrow(new IOException()).when(provider).checkAccess(otherDirFilePath);
+
+		String first = inTest.load(dirFilePath);
+		String second = inTest.load(otherDirFilePath);
+
+		assertThat(first, is(not(second)));
+	}
+
+	@Test
+	public void testDirectoryIdForNonExistingFileIsNotEmpty() throws IOException {
+		doThrow(new IOException()).when(provider).checkAccess(dirFilePath);
+
+		String result = inTest.load(dirFilePath);
+
+		assertThat(result, is(notNullValue()));
+		assertThat(result, is(not("")));
+	}
+
+	@Test
+	public void testDirectoryIdIsReadFromExistingFile() throws IOException {
+		String expectedId = "asdüßT°z¬╚‗";
+		byte[] expectedIdBytes = expectedId.getBytes(UTF_8);
+		SeekableByteChannel channel = new SeekableByteChannelMock(ByteBuffer.wrap(expectedIdBytes));
+		when(provider.newByteChannel(eq(dirFilePath), any())).thenReturn(channel);
+
+		String result = inTest.load(dirFilePath);
+
+		assertThat(result, is(expectedId));
+	}
+
+	@Test
+	public void testIOExceptionWhenExistingFileIsEmpty() throws IOException {
+		SeekableByteChannel channel = new SeekableByteChannelMock(ByteBuffer.allocate(0));
+		when(provider.newByteChannel(eq(dirFilePath), any())).thenReturn(channel);
+
+		thrown.expect(IOException.class);
+		thrown.expectMessage("Invalid, empty directory file");
+
+		inTest.load(dirFilePath);
+	}
+
+}

src/test/java/org/cryptomator/cryptofs/EffectiveOpenOptionsTest.java

@@ -63,7 +63,7 @@ public void testEmpty() {
 		assertFalse(inTest.truncateExisting());
 		assertFalse(inTest.writable());
 
-		assertThat(inTest.createOpenOptionsForEncryptedFile(), containsInAnyOrder(READ));
+		assertThat(inTest.createOpenOptionsForEncryptedFile(), containsInAnyOrder(READ, WRITE));
 	}
 
 	@Test
@@ -97,7 +97,7 @@ public void testCreate() {
 		assertFalse(inTest.truncateExisting());
 		assertFalse(inTest.writable());
 
-		assertThat(inTest.createOpenOptionsForEncryptedFile(), containsInAnyOrder(READ));
+		assertThat(inTest.createOpenOptionsForEncryptedFile(), containsInAnyOrder(READ, WRITE));
 	}
 
 	@Test
@@ -131,7 +131,7 @@ public void testCreateNew() {
 		assertFalse(inTest.truncateExisting());
 		assertFalse(inTest.writable());
 
-		assertThat(inTest.createOpenOptionsForEncryptedFile(), containsInAnyOrder(READ));
+		assertThat(inTest.createOpenOptionsForEncryptedFile(), containsInAnyOrder(READ, WRITE));
 	}
 
 	@Test
@@ -182,7 +182,7 @@ public void testDeleteOnClose() {
 		assertFalse(inTest.truncateExisting());
 		assertFalse(inTest.writable());
 
-		assertThat(inTest.createOpenOptionsForEncryptedFile(), containsInAnyOrder(READ, DELETE_ON_CLOSE));
+		assertThat(inTest.createOpenOptionsForEncryptedFile(), containsInAnyOrder(READ, WRITE, DELETE_ON_CLOSE));
 	}
 
 	@Test
@@ -199,7 +199,7 @@ public void testRead() {
 		assertFalse(inTest.truncateExisting());
 		assertFalse(inTest.writable());
 
-		assertThat(inTest.createOpenOptionsForEncryptedFile(), containsInAnyOrder(READ));
+		assertThat(inTest.createOpenOptionsForEncryptedFile(), containsInAnyOrder(READ, WRITE));
 	}
 
 	@Test
@@ -216,7 +216,7 @@ public void testSync() {
 		assertFalse(inTest.truncateExisting());
 		assertFalse(inTest.writable());
 
-		assertThat(inTest.createOpenOptionsForEncryptedFile(), containsInAnyOrder(READ, SYNC));
+		assertThat(inTest.createOpenOptionsForEncryptedFile(), containsInAnyOrder(READ, WRITE, SYNC));
 	}
 
 	@Test
@@ -233,7 +233,7 @@ public void testDSync() {
 		assertFalse(inTest.truncateExisting());
 		assertFalse(inTest.writable());
 
-		assertThat(inTest.createOpenOptionsForEncryptedFile(), containsInAnyOrder(READ, DSYNC));
+		assertThat(inTest.createOpenOptionsForEncryptedFile(), containsInAnyOrder(READ, WRITE, DSYNC));
 	}
 
 	@Test
@@ -250,7 +250,7 @@ public void testTruncateExisting() {
 		assertFalse(inTest.truncateExisting());
 		assertFalse(inTest.writable());
 
-		assertThat(inTest.createOpenOptionsForEncryptedFile(), containsInAnyOrder(READ));
+		assertThat(inTest.createOpenOptionsForEncryptedFile(), containsInAnyOrder(READ, WRITE));
 	}
 
 	@Test

src/test/java/org/cryptomator/cryptofs/WriteFileWhileReadonlyChannelIsOpenTest.java

@@ -0,0 +1,59 @@
+package org.cryptomator.cryptofs;
+
+import static java.nio.file.StandardOpenOption.READ;
+import static org.cryptomator.cryptofs.CryptoFileSystemProperties.cryptoFileSystemProperties;
+import static org.cryptomator.cryptofs.CryptoFileSystemUris.createUri;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.file.FileSystem;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardOpenOption;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import com.google.common.jimfs.Jimfs;
+
+/**
+ * @see https://github.com/cryptomator/cryptofs/issues/10
+ */
+public class WriteFileWhileReadonlyChannelIsOpenTest {
+
+	private FileSystem inMemoryFs;
+	private FileSystem fileSystem;
+	private Path root;
+
+	@Before
+	public void setup() throws IOException {
+		inMemoryFs = Jimfs.newFileSystem();
+		Path pathToVault = inMemoryFs.getRootDirectories().iterator().next().resolve("vault");
+		fileSystem = new CryptoFileSystemProvider().newFileSystem(createUri(pathToVault), cryptoFileSystemProperties().withPassphrase("asd").build());
+		root = fileSystem.getPath("/");
+	}
+
+	@After
+	public void teardown() throws IOException {
+		fileSystem.close();
+		inMemoryFs.close();
+	}
+
+	@Test
+	public void run() throws IOException {
+		Path file = root.resolve("file");
+		Files.write(file, "foo".getBytes());
+		@SuppressWarnings("unused")
+		FileChannel readOnlyChannel = FileChannel.open(file, READ);
+
+		try (FileChannel writableChannel = FileChannel.open(file, StandardOpenOption.WRITE)) {
+			ByteBuffer buffer = ByteBuffer.wrap("bar".getBytes());
+			while (buffer.hasRemaining()) {
+				writableChannel.write(buffer);
+			}
+		}
+	}
+
+}

src/test/java/org/cryptomator/cryptofs/mocks/SeekableByteChannelMock.java

@@ -12,7 +12,7 @@
 import java.nio.ByteBuffer;
 import java.nio.channels.SeekableByteChannel;
 
-class SeekableByteChannelMock implements SeekableByteChannel {
+public class SeekableByteChannelMock implements SeekableByteChannel {
 
 	private boolean open = true;
 
@@ -58,6 +58,7 @@ public int read(ByteBuffer dst) throws IOException {
 			ByteBuffer limitedSrc = buf.asReadOnlyBuffer();
 			limitedSrc.limit(limitedSrc.position() + num);
 			dst.put(limitedSrc);
+			buf.position(buf.position() + num);
 			return num;
 		}
 	}