Refs #47 git pull / git refs working

app/src/main/java/info/knacki/pass/git/BaseGitProtocol.java

@@ -0,0 +1,71 @@
+package info.knacki.pass.git;
+
+import java.util.logging.Logger;
+
+import info.knacki.pass.git.entities.GitCommit;
+import info.knacki.pass.git.entities.GitRef;
+import info.knacki.pass.io.OnResponseListener;
+import info.knacki.pass.io.OnStreamResponseListener;
+import info.knacki.pass.settings.SettingsManager;
+
+public abstract class BaseGitProtocol implements GitInterface {
+    protected final SettingsManager.Git fConfig;
+    private final Logger log = Logger.getLogger(BaseGitProtocol.class.getName());
+
+    BaseGitProtocol(SettingsManager.Git config) {
+        fConfig = config;
+    }
+
+    abstract void FetchCommit(GitRef ref, OnStreamResponseListener<GitCommit> response);
+
+    protected void GetHeadCommitFromRef(GitRef myRef, final OnStreamResponseListener<GitCommit> response) {
+        if (myRef != null) {
+            response.OnMsg("Checking out branch " +myRef.GetBranchName() +" revision " +myRef.GetHash());
+            FetchCommit(myRef, new OnStreamResponseListener<GitCommit>() {
+                @Override
+                public void OnResponse(final GitCommit result) {
+                    response.OnResponse(result);
+                }
+
+                @Override
+                public void OnMsg(String message) {
+                    response.OnMsg(message);
+                }
+
+                @Override
+                public void OnError(String msg, Throwable e) {
+                    response.OnError(msg, e);
+                }
+            });
+        } else {
+            response.OnError("Branch " +fConfig.GetBranch() + " not found on remote", null);
+        }
+    }
+
+    public GitRef GetRefFromBranchName(GitRef[] refs, String branchName) {
+        if (refs != null)
+            for (GitRef ref: refs)
+                if (ref.GetBranch().equals(branchName))
+                    return ref;
+        return null;
+    }
+
+    public GitRef GetHeadRef(GitRef[] refs) {
+        return GetRefFromBranchName(refs, fConfig.GetBranch());
+    }
+
+    public void FetchHead(final OnStreamResponseListener<GitCommit> response) {
+        GetRefs(new OnResponseListener<GitRef[]>() {
+            @Override
+            public void OnResponse(final GitRef[] result) {
+                GitRef myRef = GetHeadRef(result);
+                GetHeadCommitFromRef(myRef, response);
+            }
+
+            @Override
+            public void OnError(final String msg, final Throwable e) {
+                response.OnError(msg, e);
+            }
+        });
+    }
+}

app/src/main/java/info/knacki/pass/git/GitInterface.java

@@ -7,16 +7,8 @@ import info.knacki.pass.io.OnResponseListener;
 import info.knacki.pass.io.OnStreamResponseListener;
 
 public interface GitInterface {
-
     void GetRefs(OnResponseListener<GitRef[]> callback);
-
-    void FetchCommit(GitRef ref, OnResponseListener<GitCommit> response);
-
-    void FetchTree(GitCommit ci, OnStreamResponseListener<GitObject.GitTree> response);
-
     void FetchHead(final OnStreamResponseListener<GitCommit> response);
-
-    void FetchBlob(GitObject.GitBlob blob, OnResponseListener<byte[]> response);
-
+    void FetchBlob(GitObject.GitBlob blob, OnStreamResponseListener<byte[]> response);
     void PushBlobs(GitCommit.Builder commitBuilder, OnStreamResponseListener<Void> resp);
 }

app/src/main/java/info/knacki/pass/git/GitInterfaceFactory.java

@@ -1,13 +1,36 @@
 package info.knacki.pass.git;
 
+import android.support.annotation.NonNull;
+
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
 import info.knacki.pass.settings.SettingsManager;
 
 public class GitInterfaceFactory {
-    public static GitInterface factory(SettingsManager.Git config) {
+    private final static Logger log = Logger.getLogger(GitInterfaceFactory.class.getName());
+
+    public static class GitInterfaceException extends Throwable {
+        GitInterfaceException(String msg) {
+            super(msg);
+        }
+
+        GitInterfaceException(Throwable e) {
+            super(e.getMessage(), e);
+        }
+    }
+
+    public static @NonNull  GitInterface factory(SettingsManager.Git config) throws GitInterfaceException {
         if (config == null)
-            return null;
-        if (config.GetUrl().startsWith("http://") || config.GetUrl().startsWith("https://"))
-            return new HttpGitProtocol(config);
-        return new SSHGitProtocol(config);
+            throw new GitInterfaceException("No configuration found");
+        try {
+            if (config.GetUrl().startsWith("http://") || config.GetUrl().startsWith("https://"))
+                return new HttpGitProtocol(config);
+            return new SSHGitProtocol(config);
+        }
+        catch (Throwable e) {
+            log.log(Level.SEVERE, "Cannot create git interface: " +e.getMessage(), e);
+            throw new GitInterfaceException(e);
+        }
     }
 }

app/src/main/java/info/knacki/pass/git/GitSha1.java

@@ -21,9 +21,13 @@ public class GitSha1 {
     }
 
     public static String BytesToString(byte[] sha1Bytes) {
+        return BytesToString(sha1Bytes, 0);
+    }
+
+    public static String BytesToString(byte[] sha1Bytes, int offset) {
         StringBuilder sb = new StringBuilder();
-        for (byte i: sha1Bytes)
-            sb.append(Integer.toString((i & 0xff) + 0x100, 16).substring(1));
+        for (int i =offset; i < Math.min(sha1Bytes.length -offset, offset +20); ++i)
+            sb.append(Integer.toString((sha1Bytes[i] & 0xff) + 0x100, 16).substring(1));
         return sb.toString();
     }
 
@@ -72,4 +76,33 @@ public class GitSha1 {
         byte[] raw = getRawSha1OfPackable(obj);
         return raw.length == 0 ? "" : BytesToString(raw);
     }
+
+    public static byte[] GetRawSha1OfData(GitPackable.eType type, byte[] data) {
+        try {
+            MessageDigest sha1Builder = MessageDigest.getInstance("SHA1");
+            sha1Builder.update((GitPackableUtil.GetObjTypeString(type) +" " +data.length).getBytes());
+            sha1Builder.update(new byte[] { 0 });
+            sha1Builder.update(data);
+            return sha1Builder.digest();
+        }
+        catch (NoSuchAlgorithmException e) {
+            return new byte[]{};
+        }
+    }
+
+    public static String GetSha1OfData(GitPackable.eType type, byte[] data) {
+        byte[] raw = GetRawSha1OfData(type, data);
+        return raw.length == 0 ? "" : BytesToString(raw);
+    }
+
+    public static boolean CompareChecksums(byte[] a, byte[] b) {
+        return CompareChecksums(a, b, 0);
+    }
+
+    public static boolean CompareChecksums(byte[] checksum, byte[] data, int offset) {
+        for (int i=0; i < checksum.length; ++i)
+            if (data[offset +i] != checksum[i])
+                return false;
+        return true;
+    }
 }

app/src/main/java/info/knacki/pass/git/HttpGitProtocol.java

@@ -4,36 +4,29 @@ import java.io.IOException;
 import java.io.OutputStream;
 import java.net.MalformedURLException;
 import java.net.URL;
-import java.nio.ByteBuffer;
 import java.nio.charset.Charset;
 import java.util.HashMap;
 import java.util.Locale;
-import java.util.SortedSet;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
 import info.knacki.pass.git.entities.GitCommit;
 import info.knacki.pass.git.entities.GitObject;
-import info.knacki.pass.git.entities.GitPackable;
-import info.knacki.pass.git.entities.GitPackableUtil;
 import info.knacki.pass.git.entities.GitRef;
-import info.knacki.pass.io.CharsetHelper;
 import info.knacki.pass.io.OnResponseListener;
 import info.knacki.pass.io.OnStreamResponseListener;
-import info.knacki.pass.io.OutputStreamWithCheckSum;
 import info.knacki.pass.settings.SettingsManager;
 
 import static info.knacki.pass.io.NetworkUtils.ProtoPost;
 import static info.knacki.pass.io.NetworkUtils.protoGet;
 import static info.knacki.pass.io.NetworkUtils.protoInflateGet;
 
-class HttpGitProtocol implements GitInterface {
-    private final SettingsManager.Git fConfig;
+class HttpGitProtocol extends BaseGitProtocol {
     private GitRef[] fRefsCache = null;
     private static final Logger log = Logger.getLogger(HttpGitProtocol.class.getName());
 
     HttpGitProtocol(SettingsManager.Git config) {
-        fConfig = config;
+        super(config);
     }
 
     public void GetRefs(final OnResponseListener<GitRef[]> callback) {
@@ -56,6 +49,11 @@ class HttpGitProtocol implements GitInterface {
                                 break;
                             }
                         }
+                        if (fRefsCache[i] == null) {
+                            fRefsCache = null;
+                            callback.OnError("Cannot read references from repository", null);
+                            return;
+                        }
                     }
                     callback.OnResponse(fRefsCache);
                 }
@@ -70,22 +68,8 @@ class HttpGitProtocol implements GitInterface {
         }
     }
 
-    public void FetchCommit(final GitRef ref, final OnResponseListener<GitCommit> response) {
-        PullHash(ref.GetHash(), new OnResponseListener<byte[]>() {
-            @Override
-            public void OnResponse(byte[] result) {
-                response.OnResponse(new GitCommit(ref.GetHash(), new String(result, Charset.defaultCharset())));
-            }
-
-            @Override
-            public void OnError(String msg, Throwable e) {
-                response.OnError(msg, e);
-            }
-        });
-    }
-
     public void FetchTree(final GitCommit ci, final OnStreamResponseListener<GitObject.GitTree> response) {
-        class RecursiveFetchTreeWalker implements OnResponseListener<byte[]> {
+        class RecursiveFetchTreeWalker implements OnStreamResponseListener<byte[]> {
             private final GitObject.GitTree fRoot;
             private GitObject.GitTree fCurrentTree;
             private final OnStreamResponseListener<GitObject.GitTree> fResponseListener;
@@ -101,7 +85,7 @@ class HttpGitProtocol implements GitInterface {
 
             @Override
             public void OnResponse(byte[] result) {
-                FillTree(fCurrentTree, result);
+                fCurrentTree.Fill(result);
                 fCurrentTree = fRoot.FindNextNotInitializedTree();
                 if (fCurrentTree != null)
                     PullHash(fCurrentTree.Initialize().GetHash());
@@ -114,6 +98,11 @@ class HttpGitProtocol implements GitInterface {
                 fResponseListener.OnError(msg, e);
             }
 
+            @Override
+            public void OnMsg(String message) {
+                fResponseListener.OnMsg(message);
+            }
+
             private void PullHash(String hash) {
                 fResponseListener.OnMsg("Reading tree " +hash);
                 HttpGitProtocol.this.PullHash(hash, this);
@@ -122,101 +111,16 @@ class HttpGitProtocol implements GitInterface {
             private void PullHash(byte[] hash) {
                 PullHash(GitSha1.BytesToString(hash));
             }
-
-            private void FillTree(final GitObject.GitTree tree, byte[] data) {
-                int i = 0;
-
-                while (i < data.length) {
-                    byte[] mode = null;
-                    int len;
-                    for (len =0; i +len <data.length && len < 8; ++len) {
-                        if (data[i + len] == ' ') {
-                            mode = new byte[len];
-                            System.arraycopy(data, i, mode, 0, len);
-                            i += len + 1;
-                            break;
-                        }
-                    }
-                    if (mode == null)
-                        break;
-                    for (len =0; i +len < data.length && data[i +len] != 0; ++len);
-                    byte[] filenameBytes = new byte[len];
-                    System.arraycopy(data, i, filenameBytes, 0, len);
-                    i += len +1;
-                    if (i +20 > data.length)
-                        break;
-                    byte []sha1 = new byte[20];
-                    System.arraycopy(data, i, sha1, 0, 20);
-                    i += 20;
-                    tree.AddItem(GitObject.factory(tree, mode, CharsetHelper.ByteArrayToString(filenameBytes), sha1));
-                }
-            }
         }
 
         new RecursiveFetchTreeWalker(ci, response).run();
     }
 
-    @Override
-    public void FetchBlob(final GitObject.GitBlob blob, final OnResponseListener<byte[]> response) {
+    public void FetchBlob(final GitObject.GitBlob blob, final OnStreamResponseListener<byte[]> response) {
         PullHash(GitSha1.BytesToString(blob.GetHash()), response);
     }
 
-    public void FetchHead(final OnStreamResponseListener<GitCommit> response) {
-        GetRefs(new OnResponseListener<GitRef[]>() {
-            @Override
-            public void OnResponse(final GitRef[] result) {
-                GitRef myRef = null;
-                response.OnMsg("Found refs: ");
-                for (GitRef ref: result) {
-                    response.OnMsg("\t> "+ref.GetBranch());
-                    if (ref.GetBranch().equals(fConfig.GetBranch()))
-                        myRef = ref;
-                }
-                if (myRef != null) {
-                    response.OnMsg("Checking out branch " +myRef.GetBranchName() +" revision " +myRef.GetHash());
-                    FetchCommit(myRef, new OnResponseListener<GitCommit>() {
-                        @Override
-                        public void OnResponse(final GitCommit result) {
-                            response.OnMsg("Finished read commit");
-                            response.OnMsg(result.GetMessage());
-                            response.OnMsg("Reading tree #" +GitSha1.BytesToString(result.GetTreeHash()));
-                            FetchTree(result, new OnStreamResponseListener<GitObject.GitTree>() {
-                                @Override
-                                public void OnMsg(String message) {
-                                    response.OnMsg(message);
-                                }
-
-                                @Override
-                                public void OnResponse(GitObject.GitTree tree) {
-                                    response.OnMsg("Finished reading tree");
-                                    response.OnResponse(result);
-                                }
-
-                                @Override
-                                public void OnError(String msg, Throwable e) {
-                                    response.OnError(msg, e);
-                                }
-                            });
-                        }
-
-                        @Override
-                        public void OnError(String msg, Throwable e) {
-                            response.OnError(msg, e);
-                        }
-                    });
-                } else {
-                    response.OnError("Branch " +fConfig.GetBranch() + " not found on remote", null);
-                }
-            }
-
-            @Override
-            public void OnError(final String msg, final Throwable e) {
-                response.OnError(msg, e);
-            }
-        });
-    }
-
-    private void PullHash(String hash, final OnResponseListener<byte[]> response) {
+    protected void PullHash(String hash, final OnStreamResponseListener<byte[]> response) {
         URL url;
         try {
             url = new URL(fConfig.GetUrl() + "/objects/" + hash.substring(0, 2) + "/" + hash.substring(2));
@@ -228,24 +132,46 @@ class HttpGitProtocol implements GitInterface {
         protoInflateGet(url, fConfig, response);
     }
 
-    public boolean makePack(SortedSet<GitPackable> objectsToPack, OutputStream out) throws IOException
-    {
-        OutputStreamWithCheckSum msg = new OutputStreamWithCheckSum(out);
-        msg.write("PACK")
-            .write(new byte[] { 0, 0, 0, 2 } )
-            .write(ByteBuffer.allocate(4).putInt(objectsToPack.size()).array());
-        for (GitPackable i: objectsToPack) {
-            byte[] pack = i.GetPack();
-            if (null == pack)
-                return false;
-            msg.write(GitPackableUtil.getObjHeader(i.GetPackableType(), pack.length))
-                .write(GitPackableUtil.deflate(pack));
-            log.info("Writing pack " +i.GetPackableType() +", " +GitSha1.getSha1OfPackable(i) +new String(i.GetPack()));
-        }
-        msg.writeSha1();
-        return true;
+    public void FetchCommit(final GitRef ref, final OnStreamResponseListener<GitCommit> response) {
+        PullHash(ref.GetHash(), new OnStreamResponseListener<byte[]>() {
+            @Override
+            public void OnResponse(byte[] result) {
+                GitCommit ci = new GitCommit(ref.GetHash(), new String(result, Charset.defaultCharset()));
+                response.OnMsg("Finished read commit");
+                response.OnMsg(ci.GetMessage());
+                response.OnMsg("Reading tree #" +GitSha1.BytesToString(ci.GetTreeHash()));
+                FetchTree(ci, new OnStreamResponseListener<GitObject.GitTree>() {
+                    @Override
+                    public void OnMsg(String message) {
+                        response.OnMsg(message);
+                    }
+
+                    @Override
+                    public void OnResponse(GitObject.GitTree tree) {
+                        response.OnMsg("Finished reading tree");
+                        response.OnResponse(ci);
+                    }
+
+                    @Override
+                    public void OnError(String msg, Throwable e) {
+                        response.OnError(msg, e);
+                    }
+                });
+            }
+
+            @Override
+            public void OnError(String msg, Throwable e) {
+                response.OnError(msg, e);
+            }
+
+            @Override
+            public void OnMsg(String message) {
+                response.OnMsg(message);
+            }
+        });
     }
 
+
     public void PushBlobs(final GitCommit.Builder commit, final OnStreamResponseListener<Void> response) {
         GetRefs(new OnResponseListener<GitRef[]>() {
             @Override
@@ -280,7 +206,8 @@ class HttpGitProtocol implements GitInterface {
                                     result.write(String.format(Locale.US, "%04X", msgLine.length +4).getBytes());
                                     result.write(msgLine);
                                     result.write("0000".getBytes());
-                                    if (!makePack(commit.PreparePack(), result)) {
+                                    Pacman pac = new Pacman(commit.PreparePack());
+                                    if (!pac.Write(result)) {
                                         OnError("Pack error", null);
                                         return;
                                     }

app/src/main/java/info/knacki/pass/git/Pacman.java

@@ -0,0 +1,111 @@
+package info.knacki.pass.git;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.nio.ByteBuffer;
+import java.util.ArrayDeque;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.logging.Logger;
+
+import info.knacki.pass.git.entities.GitCommit;
+import info.knacki.pass.git.entities.GitObject;
+import info.knacki.pass.git.entities.GitPackable;
+import info.knacki.pass.git.entities.GitPackableUtil;
+import info.knacki.pass.io.OutputStreamWithCheckSum;
+
+class Pacman {
+    private static final Logger log = Logger.getLogger(Pacman.class.getName());
+    Collection<GitPackable> fPacked;
+    Map<GitPackable.eType, Collection<GitPackable>> fPackedByType;
+
+    public Pacman(Collection<GitPackable> objectsToPack) {
+        fPacked = objectsToPack;
+        fPackedByType = new HashMap<>();
+        for (GitPackable i: fPacked) {
+            Collection<GitPackable> col = fPackedByType.get(i.GetPackableType());
+            if (col == null) {
+                col = new ArrayDeque<>();
+                fPackedByType.put(i.GetPackableType(), col);
+            }
+            col.add(i);
+        }
+    }
+
+    private GitObject.GitTree FindTree(byte[] hash) {
+        Collection<GitPackable> col = fPackedByType.get(GitPackable.eType.eType_Tree);
+        if (col != null)
+            for (GitPackable i: col)
+                if (GitSha1.CompareChecksums(hash, GitSha1.getRawSha1OfPackable(i)))
+                    return (GitObject.GitTree) i;
+        return null;
+    }
+
+    private GitObject.GitRawData FindBlob(byte[] hash) {
+        Collection<GitPackable> col = fPackedByType.get(GitPackable.eType.eType_Blob);
+        if (col != null)
+            for (GitPackable i: col)
+                if (GitSha1.CompareChecksums(hash, GitSha1.getRawSha1OfPackable(i)))
+                    return (GitObject.GitRawData) i;
+        return null;
+    }
+
+    private void BuildTree(GitObject.GitTree root) throws PacmanBuilder.InvalidPackException {
+        GitObject.GitTree nextUninitialized = root;
+        do {
+            if (!nextUninitialized.IsRoot()) {
+                GitObject.GitTree realTree = FindTree(nextUninitialized.GetHash());
+                if (realTree == null)
+                    throw new PacmanBuilder.InvalidPackException("Cannot find object in pack");
+                nextUninitialized.GetParent().SetRealObject(nextUninitialized.GetFilename(), new GitObject.GitTree(nextUninitialized.GetParent(), realTree, nextUninitialized.GetFilename()));
+                nextUninitialized = realTree;
+            }
+            for (GitObject.GitBlob i: nextUninitialized.GetBlobs()) {
+                GitObject.GitRawData blob = FindBlob(i.GetHash());
+                if (blob == null)
+                    throw new PacmanBuilder.InvalidPackException("Cannot find object in pack");
+                nextUninitialized.SetRealObject(i.GetFilename(), new GitObject.GitRawData(nextUninitialized, i, blob));
+            }
+        } while ((nextUninitialized = root.FindNextNotInitializedTree()) != null);
+    }
+
+    private GitCommit BuildCommit(GitCommit ci) throws PacmanBuilder.InvalidPackException {
+        GitObject.GitTree tree = ci.GetTree();
+        if (tree == null) {
+            tree = FindTree(ci.GetTreeHash());
+            if (tree != null)
+                ci.SetTree(tree);
+        }
+        if (tree != null)
+            BuildTree(tree);
+        return ci;
+    }
+
+    public GitCommit BuildCommit(String hash) throws PacmanBuilder.InvalidPackException {
+        Collection<GitPackable> col = fPackedByType.get(GitPackable.eType.eType_Commit);
+        if (col != null)
+            for (GitPackable i: col)
+                if (hash.equals(((GitCommit) i).GetHash()))
+                    return BuildCommit((GitCommit) i);
+        return null;
+    }
+
+    public boolean Write(OutputStream out) throws IOException
+    {
+        OutputStreamWithCheckSum msg = new OutputStreamWithCheckSum(out);
+        msg.write("PACK")
+                .write(new byte[] { 0, 0, 0, 2 } )
+                .write(ByteBuffer.allocate(4).putInt(fPacked.size()).array());
+        for (GitPackable i: fPacked) {
+            byte[] pack = i.GetPack();
+            if (null == pack)
+                return false;
+            GitPackable.PackV2Header header = new GitPackable.PackV2Header(i.GetPackableType(), pack.length);
+            msg.write(GitPackableUtil.getObjHeader(header)).write(GitPackableUtil.deflate(pack));
+            log.info("Writing pack " +i.GetPackableType() +", " +GitSha1.getSha1OfPackable(i) +new String(i.GetPack()));
+        }
+        msg.writeSha1();
+        return true;
+    }
+}

app/src/main/java/info/knacki/pass/git/PacmanBuilder.java

@@ -0,0 +1,155 @@
+package info.knacki.pass.git;
+
+import java.nio.ByteBuffer;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.ArrayDeque;
+import java.util.logging.Logger;
+import java.util.zip.DataFormatException;
+import java.util.zip.Inflater;
+
+import info.knacki.pass.git.entities.GitPackable;
+import info.knacki.pass.git.entities.GitPackableFactory;
+import info.knacki.pass.git.entities.GitPackableUtil;
+import info.knacki.pass.io.CharsetHelper;
+
+public class PacmanBuilder {
+    private final static Logger log = Logger.getLogger(PacmanBuilder.class.getName());
+
+    private byte[] fBuffer;
+    private int fPos;
+
+    public static class InvalidPackException extends Throwable {
+        InvalidPackException(String msg) {
+            super(msg);
+        }
+
+        InvalidPackException(String msg, Throwable cause) {
+            super(msg, cause);
+        }
+    }
+
+    public Pacman build(byte[] data) throws InvalidPackException {
+        if (data == null)
+            throw new InvalidPackException("No data provided");
+        final String header = CharsetHelper.ByteArrayToString(data, 0, 4);
+        if (!"PACK".equals(header))
+            throw new InvalidPackException("Invalid header " +header);
+
+        try {
+            MessageDigest checksum = MessageDigest.getInstance("SHA1");
+            checksum.update(data, 0, data.length - 20);
+            if (!GitSha1.CompareChecksums(checksum.digest(), data, data.length - 20))
+                throw new InvalidPackException("Checksum mismatch");
+        }
+        catch (NoSuchAlgorithmException e) {
+            throw new InvalidPackException("Cannot check pack integrity: " +e.getMessage(), e);
+        }
+
+        final int packVersion = ByteBuffer.wrap(data, 4, 4).getInt();
+        fBuffer = new byte[data.length -8 - 20];
+        fPos = 0;
+        System.arraycopy(data, 8, fBuffer, 0, fBuffer.length);
+
+        switch (packVersion) {
+            case 2:
+                return ReadPackV2();
+            default:
+                throw new InvalidPackException("Unsupported pack version " +packVersion);
+        }
+    }
+
+    private GitPackable.PackV2Header ReadPackV2Header() throws InvalidPackException {
+        int currentByte;
+        int nbBits = 4;
+
+        GitPackable.PackV2Header header = new GitPackable.PackV2Header();
+        currentByte = fBuffer[fPos++];
+        final int type = (currentByte & 0b01110000) >> 4;
+        header.type = GitPackableUtil.getObjType(type);
+        if (header.type == null)
+            throw new InvalidPackException("Unknown object type " +type +" in pack");
+        header.length = currentByte & 0b00001111;
+        while ((currentByte & 0b10000000) != 0) {
+            currentByte = fBuffer[fPos++];
+            header.length += (currentByte & 0b01111111) << nbBits;
+            nbBits += 7;
+        }
+        return header;
+    }
+
+    private byte[] InflateObject(GitPackable.PackV2Header header) throws InvalidPackException {
+        byte[] data = new byte[header.length];
+        try {
+            Inflater inf = new Inflater(false);
+            int totalRead = 0;
+            do {
+                if (inf.needsInput())
+                    inf.setInput(fBuffer, (int) (fPos +inf.getBytesRead()), fBuffer.length -fPos -(int)inf.getBytesRead());
+                totalRead += inf.inflate(data, totalRead, 1);
+            } while (!inf.finished() && totalRead < header.length);
+            fPos += inf.getBytesRead();
+        } catch (DataFormatException e) {
+            throw new InvalidPackException("Zip error: " + e.getMessage(), e);
+        }
+        return data;
+    }
+
+    private void InflateDiscard(int inflatedSize) throws InvalidPackException {
+        byte[] data = new byte[1];
+        try {
+            Inflater inf = new Inflater(false);
+            int totalRead = 0;
+            do {
+                if (inf.needsInput())
+                    inf.setInput(fBuffer, (int) (fPos +inf.getBytesRead()), fBuffer.length -fPos -(int)inf.getBytesRead());
+                totalRead += inf.inflate(data, 0, 1);
+            } while (!inf.finished() && totalRead < inflatedSize);
+            fPos += inf.getBytesRead();
+        } catch (DataFormatException e) {
+            throw new InvalidPackException("Zip error: " + e.getMessage(), e);
+        }
+    }
+
+    private Pacman ReadPackV2() throws InvalidPackException {
+        final int packCount = ByteBuffer.wrap(fBuffer, fPos, 4).getInt();
+        fPos += 4;
+        log.info("Found " +packCount +" object in pack file");
+        ArrayDeque<GitPackable> packed = new ArrayDeque<>();
+
+        for (int i =0; i < packCount; ++i) {
+            GitPackable.PackV2Header header = ReadPackV2Header();
+
+            switch (header.type) {
+                case eType_Blob:
+                case eType_Commit:
+                case eType_Tree:
+                case eType_Tag:
+                    byte[] inflated = InflateObject(header);
+                    String hash = GitSha1.GetSha1OfData(header.type, inflated);
+                    GitPackable pack = GitPackableFactory.build(header.type, hash, inflated);
+
+                    if (pack == null) {
+                        log.warning("Cannot parse object type " + header.type);
+                        continue;
+                    }
+                    packed.add(pack);
+                    log.info("Read " +GitSha1.getSha1OfPackable(pack) +" " + pack + " from pack");
+                    break;
+
+                case eType_RefDelta:
+                    log.info("Found ref_delta from base " +GitSha1.BytesToString(fBuffer, fPos));
+                    fPos += 20;
+                    InflateDiscard(header.length);
+                    break;
+
+                case eType_OfsDelta:
+                    while ((fBuffer[fPos++] & 0b10000000) != 0) {}
+                    InflateDiscard(header.length);
+                    break;
+            }
+        }
+        log.info("End reading pack, " +packed.size() +" object created");
+        return new Pacman(packed);
+    }
+}

app/src/main/java/info/knacki/pass/git/SSHGitProtocol.java

@@ -6,8 +6,8 @@ import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.OutputStream;
+import java.security.InvalidParameterException;
 import java.util.ArrayDeque;
-import java.util.Collection;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
@@ -16,6 +16,7 @@ import info.knacki.pass.git.entities.GitObject;
 import info.knacki.pass.git.entities.GitRef;
 import info.knacki.pass.io.AppendableInputStream;
 import info.knacki.pass.io.CharsetHelper;
+import info.knacki.pass.io.FileUtils;
 import info.knacki.pass.io.OnErrorListener;
 import info.knacki.pass.io.OnResponseListener;
 import info.knacki.pass.io.OnStreamResponseListener;
@@ -23,60 +24,131 @@ import info.knacki.pass.io.ssh.SSHConnection;
 import info.knacki.pass.io.ssh.SSHFactory;
 import info.knacki.pass.settings.SettingsManager;
 
-public class SSHGitProtocol implements GitInterface {
+public class SSHGitProtocol extends BaseGitProtocol {
     private final static Logger log = Logger.getLogger(SSHGitProtocol.class.getName());
-    private final SettingsManager.Git fConfig;
+    private final SSHUrl fRepoUrl;
+
+    private final class ActiveSSHWrapper {
+        final SSHConnection fConnection;
+        final OutputStream fStdin;
+        final InputStream fStdout;
+        final InputStream fStderr;
+
+        ActiveSSHWrapper(SSHConnection con, OutputStream stdin, InputStream stdout, InputStream stderr) {
+            fConnection = con;
+            fStdin = stdin;
+            fStdout = stdout;
+            fStderr = stderr;
+        }
+    }
+
+    private ActiveSSHWrapper fActiveConnection = null;
+
+    private final class SSHUrl implements SSHConnection.ConnectionParams {
+        private final String repoHost;
+        final String repoName;
+
+        SSHUrl(String url) {
+            if (url.contains("://"))
+                url = url.substring(url.indexOf("://"));
+            int repoSep = url.indexOf(':');
+            if (repoSep < 0)
+                throw new InvalidParameterException("Cannot find repository name");
+            repoHost = url.substring(0, repoSep);
+            repoName = url.substring(repoSep + 1);
+        }
+
+        @Override
+        public String GetHostname() {
+            return repoHost;
+        }
+
+        @Override
+        public boolean HasAuthentication() {
+            return fConfig.HasAuthentication();
+        }
+
+        @Override
+        public String GetUser() {
+            return fConfig.GetUser();
+        }
+
+        @Override
+        public String GetPassword() {
+            return fConfig.GetPassword();
+        }
+
+        @Override
+        public String GetPrivateKey() {
+            return fConfig.GetPrivateKey();
+        }
+    }
 
     SSHGitProtocol(SettingsManager.Git config) {
-        fConfig = config;
+        super(config);
+        fRepoUrl = new SSHUrl(config.GetUrl());
     }
 
-    private Collection<GitRef> GetRefs(SSHConnection con, OutputStream stdin, InputStream stdout) {
+    private byte[] ReadLine(InputStream in) throws IOException {
+        byte[] lineLenBytes = new byte[4];
+        if (in.read(lineLenBytes, 0, 4) < 4) {
+            return null;
+        }
+        int lineLen = 0;
+        try {
+            lineLen = Integer.parseInt(CharsetHelper.ByteArrayToString(lineLenBytes), 16);
+        }
+        catch (NumberFormatException e) {
+            ByteArrayOutputStream stream = new ByteArrayOutputStream();
+            stream.write(lineLenBytes);
+            byte[] tmp = new byte[1024];
+            int read = in.read(tmp);
+            stream.write(tmp, 0, read);
+            String error = CharsetHelper.ByteArrayToString(stream.toByteArray());
+            throw new NumberFormatException(error);
+        }
+        if (lineLen == 0) {
+            return null;
+        }
+
+        lineLen -= 4;
+        if (lineLen == 0)
+            return new byte[] {};
+        byte[] line = new byte[lineLen];
+        if (in.read(line) != lineLen) {
+            return null;
+        }
+        for (int i =0; i < lineLen; ++i)
+            if (line[i] == 0)
+                lineLen = i;
+        return line;
+    }
+
+    private GitRef[] GetRefs(ActiveSSHWrapper sshConnection, OnErrorListener errorListener) {
         ArrayDeque<GitRef> references = new ArrayDeque<>();
 
         try {
-            while (true) {
-                byte[] hash = new byte[44];
-                if (stdout.read(hash, 0, 4) < 4) {
-                    break;
-                }
-                if (CharsetHelper.ByteArrayToString(hash, 0, 4).equals("0000") && stdout.available() == 0) {
-                    break; // End Hash
-                }
-                // Read the remaining of the hash
-                if (stdout.read(hash, 4, 40) < 40) {
-                    break;
-                }
+            byte[] line;
+            while ((line = ReadLine(sshConnection.fStdout)) != null) {
+                GitRef ref = new GitRef(CharsetHelper.ByteArrayToString(line, 0, 40), CharsetHelper.ByteArrayToString(line, 41, line.length -42));
 
-                ByteArrayOutputStream buffer = null;
-                boolean ignoreToEol = false;
-                // read the ref name
-                while (true) {
-                    byte ch = (byte) stdout.read();
-                    if (ch == 0)
-                        ignoreToEol = true; // ignore server caps
-                    if (ch == '\n')
-                        break;
-                    if (buffer == null)
-                        buffer = new ByteArrayOutputStream();
-                    else if (!ignoreToEol)
-                        buffer.write(ch);
-                }
-                String branchRef;
-                if (buffer != null && (branchRef = CharsetHelper.ByteArrayToString(buffer.toByteArray())).startsWith("refs/heads/")){
-                    GitRef ref = new GitRef(CharsetHelper.ByteArrayToString(hash), branchRef);
+                if (ref.GetBranch().startsWith("refs/heads/")) {
                     references.add(ref);
                     log.info("Found ref: " + ref);
                 }
             }
         }
-        catch (IOException e) {
-            log.log(Level.SEVERE, "Cannot read from ssh command: " +e.getMessage(), e);
+        catch (IOException | NumberFormatException e) {
+            final String errorMsg = "Cannot read from ssh command: " +e.getMessage();
+            log.log(Level.SEVERE, errorMsg, e);
+            errorListener.OnError(errorMsg, e);
+            return null;
         }
-        return references;
+        GitRef[] refs = new GitRef[references.size()];
+        return references.toArray(refs);
     }
 
-    public void ListenForErrors(InputStream stderr, OnErrorListener OnError) {
+    private void ListenForErrors(InputStream stderr, OnErrorListener OnError) {
         (new Thread() {
             @Override
             public void run() {
@@ -97,43 +169,151 @@ public class SSHGitProtocol implements GitInterface {
 
     @Override
     public void GetRefs(OnResponseListener<GitRef[]> callback) {
-        AppendableInputStream stdin = new AppendableInputStream();
+        if (fActiveConnection != null) {
+            GitRef[] refs = GetRefs(fActiveConnection, callback);
+            if (refs != null)
+                callback.OnResponse(refs);
+        } else {
+            AppendableInputStream stdin = new AppendableInputStream();
 
-        SSHFactory
-            .createInstance(fConfig, "git-upload-pack isundil/pass") // FIXME tmp
-            .SetOnConnectionReadyListener((connection, stdout, stderr) -> {
-                ListenForErrors(stderr, (msg, exc) -> log.severe(msg));
-                Collection<GitRef> references = GetRefs(connection, stdin.GetWriter(), stdout);
-                stdin.closeUnsafe();
-                GitRef[] refs = new GitRef[references.size()];
-                callback.OnResponse(references.toArray(refs));
-                connection.disconnect();
-            })
-            .connect();
+            SSHFactory
+                    .createInstance(fRepoUrl, "git-upload-pack " + fRepoUrl.repoName)
+                    .SetOnConnectionReadyListener((connection, stdout, stderr) -> {
+                        ListenForErrors(stderr, (msg, exc) -> log.severe(msg));
+                        GitRef[] refs = GetRefs(new ActiveSSHWrapper(connection, stdin.GetWriter(), stdout, stderr), callback);
+                        connection.disconnect();
+                        if (refs != null)
+                            callback.OnResponse(refs);
+                    })
+                    .connect();
+        }
     }
 
-    @Override
-    public void FetchCommit(GitRef ref, OnResponseListener<GitCommit> response) {
+    private byte[] GitLine(String line) {
+        String lineResult;
+        if (line == null) {
+            lineResult = "0000";
+        } else {
+            lineResult = String.format("%04x%s\n", line.length() +5, line);
+        }
+        return CharsetHelper.StringToByteArray(lineResult);
+    }
 
+    private byte[] PullPackData(ActiveSSHWrapper sshWrapper, String hash, OnStreamResponseListener<byte[]> listener) {
+        try {
+            ListenForErrors(sshWrapper.fStderr, (msg, e) -> listener.OnMsg(msg));
+            ByteArrayOutputStream out = new ByteArrayOutputStream();
+            out.write(GitLine("want " +hash));
+            out.write(GitLine("deepen 1"));
+            out.write(GitLine(null));
+            out.write(GitLine("done"));
+            log.severe(CharsetHelper.ByteArrayToString(out.toByteArray()));
+            sshWrapper.fStdin.write(out.toByteArray());
+            String line;
+            do {
+                byte[] b = ReadLine(sshWrapper.fStdout);
+                line = b == null ? null : CharsetHelper.ByteArrayToString(b);
+            } while (line == null || !"NAK\n".equals(line));
+            return FileUtils.ReadAllStream(sshWrapper.fStdout);
+        }
+        catch (IOException e) {
+            log.log(Level.SEVERE, "Cannot get hash " +hash +": " +e.getMessage(), e);
+            return null;
+        }
     }
 
-    @Override
-    public void FetchTree(GitCommit ci, OnStreamResponseListener<GitObject.GitTree> response) {
+    private void PullPackData(String hash, OnStreamResponseListener<byte[]> response) {
+        if (fActiveConnection != null) {
+            byte[] result = PullPackData(fActiveConnection, hash, response);
+            response.OnResponse(result);
+        } else {
+            AppendableInputStream stdin = new AppendableInputStream();
 
+            SSHFactory
+                    .createInstance(fRepoUrl, "git-upload-pack " + fRepoUrl.repoName)
+                    .SetOnConnectionReadyListener((connection, stdout, stderr) -> {
+                        ListenForErrors(stderr, (msg, exc) -> log.severe(msg));
+                        byte[] data = PullPackData(new ActiveSSHWrapper(connection, stdin.GetWriter(), stdout, stderr), hash, response);
+                        connection.disconnect();
+                        response.OnResponse(data);
+                    })
+                    .connect();
+        }
     }
 
     @Override
-    public void FetchHead(OnStreamResponseListener<GitCommit> response) {
+    public void FetchCommit(GitRef headRef, OnStreamResponseListener<GitCommit> response) {
+        PullPackData(headRef.GetHash(), new OnStreamResponseListener<byte[]>() {
+            @Override
+            public void OnMsg(String message) {
+                response.OnMsg(message);
+            }
+
+            @Override
+            public void OnResponse(byte[] packData) {
+                try {
+                    Pacman pacman = new PacmanBuilder().build(packData);
+                    OnMsg("Read " +pacman.fPacked.size() +" objects from pack file");
+                    response.OnResponse(pacman.BuildCommit(headRef.GetHash()));
+                }
+                catch (PacmanBuilder.InvalidPackException e) {
+                    response.OnError("Cannot read pack object: " +e.getMessage(), e);
+                    return;
+                }
+            }
 
+            @Override
+            public void OnError(String msg, Throwable e) {
+                response.OnError(msg, e);
+            }
+        });
     }
 
     @Override
-    public void FetchBlob(GitObject.GitBlob blob, OnResponseListener<byte[]> response) {
+    public void PushBlobs(GitCommit.Builder commitBuilder, OnStreamResponseListener<Void> resp) {
 
     }
 
     @Override
-    public void PushBlobs(GitCommit.Builder commitBuilder, OnStreamResponseListener<Void> resp) {
+    public void FetchBlob(GitObject.GitBlob blob, OnStreamResponseListener<byte[]> response) {
+        if (blob instanceof GitObject.GitRawData)
+            response.OnResponse(((GitObject.GitRawData) blob).GetData());
+        else
+            response.OnError("Unsupported object " +blob.GetHash(), new InvalidParameterException());
+    }
+
+    @Override
+    public void FetchHead(OnStreamResponseListener<GitCommit> response) {
+        AppendableInputStream stdin = new AppendableInputStream();
+
+        SSHFactory
+            .createInstance(fRepoUrl, "git-upload-pack " +fRepoUrl.repoName)
+            .SetOnConnectionReadyListener((connection, stdout, stderr) -> {
+                fActiveConnection = new ActiveSSHWrapper(connection, stdin.GetWriter(), stdout, stderr);
+                GitRef ref = GetHeadRef(GetRefs(fActiveConnection, response));
+                if (ref == null)
+                    return;
+                GetHeadCommitFromRef(ref, new OnStreamResponseListener<GitCommit>() {
+                    @Override
+                    public void OnMsg(String message) {
+                        response.OnMsg(message);
+                    }
 
+                    @Override
+                    public void OnResponse(GitCommit result) {
+                        fActiveConnection.fConnection.disconnect();
+                        fActiveConnection = null;
+                        response.OnResponse(result);
+                    }
+
+                    @Override
+                    public void OnError(String msg, Throwable e) {
+                        fActiveConnection.fConnection.disconnect();
+                        fActiveConnection = null;
+                        response.OnError(msg, e);
+                    }
+                });
+            })
+            .connect(stdin);
     }
 }

app/src/main/java/info/knacki/pass/git/entities/GitCommit.java

@@ -20,13 +20,13 @@ public class GitCommit implements GitPackable {
     private final String fMessage;
     private Date fTime;
 
-    public GitCommit(String hash, String sha1Content) {
-        int pos = sha1Content.indexOf('\0');
+    public GitCommit(String hash, String commitContent) {
+        int pos = commitContent.indexOf('\0');
 
         if (pos >= 0)
-            sha1Content = sha1Content.substring(pos +1);
+            commitContent = commitContent.substring(pos +1);
         StringBuilder message = null;
-        for (String line: sha1Content.split("\n")) {
+        for (String line: commitContent.split("\n")) {
             if (message != null)
                 message.append(line).append('\n');
             else if ("".equals(line))
@@ -91,16 +91,26 @@ public class GitCommit implements GitPackable {
 
     @Override
     public byte[] GetPack() {
-        String dateStr = (fTime.getTime() / 1000) +" " +(new SimpleDateFormat("Z", Locale.US).format(fTime));
-        String data = "tree " +GitSha1.BytesToString(fTree.GetHash()) +"\n" +
+        String dateStr = "";
+        if (fTime != null)
+            dateStr = " " +(fTime.getTime() / 1000) +" " +(new SimpleDateFormat("Z", Locale.US).format(fTime));
+        String data = "tree " +(fTree == null ? GitSha1.BytesToString(fTreeHash) : GitSha1.BytesToString(fTree.GetHash())) +"\n" +
                 "parent " +GetParent() +"\n" +
-                "author " +GetAuthor() +" " +dateStr +"\n" +
-                "committer " +GetCommitter() +" " +dateStr +"\n" +
+                "author " +GetAuthor() +dateStr +"\n" +
+                "committer " +GetCommitter() +dateStr +"\n" +
                 "\n" +
                 fMessage +"\n";
         return data.getBytes();
     }
 
+    public GitCommit SetTree(GitObject.GitTree tree) {
+        fTree = tree;
+        fTreeHash = GitSha1.getRawSha1OfPackable(tree);
+        return this;
+    }
+
+    public String GetHash() { return fHash; }
+
     public static class Builder {
         private final GitCommit co;
         private final GitObject.GitTree fTree;
@@ -156,4 +166,9 @@ public class GitCommit implements GitPackable {
             return packs;
         }
     }
+
+    @Override
+    public String toString() {
+        return "Commit " +fHash;
+    }
 }

app/src/main/java/info/knacki/pass/git/entities/GitObject.java

@@ -7,7 +7,7 @@ import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.IOException;
-import java.io.InputStream;
+import java.util.ArrayDeque;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.SortedSet;
@@ -15,6 +15,8 @@ import java.util.TreeSet;
 import java.util.logging.Logger;
 
 import info.knacki.pass.git.GitSha1;
+import info.knacki.pass.io.CharsetHelper;
+import info.knacki.pass.io.FileUtils;
 
 public abstract class GitObject implements Comparable<GitObject>, GitPackable {
     final GitTree fParent;
@@ -50,18 +52,7 @@ public abstract class GitObject implements Comparable<GitObject>, GitPackable {
         }
 
         public static byte[] GetFilePack(File f) throws IOException {
-            ByteArrayOutputStream out = new ByteArrayOutputStream();
-            InputStream input = new FileInputStream(f);
-            int numRead = 0;
-            while (numRead != -1)
-            {
-                byte[] buffer = new byte[1024];
-                numRead = input.read(buffer);
-                if (numRead > 0)
-                    out.write(buffer, 0, numRead);
-            }
-            input.close();
-            return out.toByteArray();
+            return FileUtils.ReadAllStream(new FileInputStream(f));
         }
 
         @Override
@@ -80,8 +71,40 @@ public abstract class GitObject implements Comparable<GitObject>, GitPackable {
         }
     }
 
+    public static class GitRawData extends GitBlob {
+        private final byte[] fData;
+
+        GitRawData(byte[] sha1, byte[] data) {
+            super(null, new byte[] { 49, 48, 48, 54, 52, 52 }, "", sha1);
+            fData = data;
+        }
+
+        public GitRawData(GitTree parent, byte[] mode, String name, byte[] sha1) {
+            super(parent, mode, name, sha1);
+            fData = null;
+        }
+
+        public GitRawData(GitTree parent, GitBlob emptyBlob, GitRawData prev) {
+            super(parent, new byte[] { 49, 48, 48, 54, 52, 52 }, emptyBlob.GetFilename(), prev.GetHash());
+            fData = prev.fData;
+        }
+
+        @Override
+        public eType GetPackableType() {
+            return eType.eType_Blob;
+        }
+
+        @Override
+        public byte[] GetPack() {
+            return GetData();
+        }
+
+        public byte[] GetData() { return fData; }
+    }
+
     public static class GitTree extends GitObject {
         HashMap<String, GitObject> fItems = null;
+        ArrayDeque<String> fItemOrder;
 
         private GitTree(GitTree parent, byte[] mode, String name, byte[] sha1) {
             super(parent, mode, name, sha1);
@@ -95,6 +118,8 @@ public abstract class GitObject implements Comparable<GitObject>, GitPackable {
                 GitObject oCopy = src instanceof GitTree ? new GitTree(this, (GitTree) src) : new GitBlob(this, (GitBlob) src);
                 fItems.put(o.getKey(), oCopy);
             }
+            for (String i: copy.fItemOrder)
+                fItemOrder.push(i);
         }
 
         GitTree(byte[] sha1) {
@@ -105,8 +130,15 @@ public abstract class GitObject implements Comparable<GitObject>, GitPackable {
             super(parent, new byte[] { '4', '0', '0', '0', '0' }, filename, null);
         }
 
+        public GitTree(GitTree parent, GitTree content, String filename) {
+            this(parent, filename);
+            fItems = content.fItems;
+            fItemOrder = content.fItemOrder;
+        }
+
         public GitTree Initialize() {
             fItems = new HashMap<>();
+            fItemOrder = new ArrayDeque<>();
             return this;
         }
 
@@ -133,6 +165,7 @@ public abstract class GitObject implements Comparable<GitObject>, GitPackable {
 
         public GitTree AddItem(GitObject item) {
             fItems.put(item.fName, item);
+            fItemOrder.push(item.fName);
             return this;
         }
 
@@ -150,7 +183,10 @@ public abstract class GitObject implements Comparable<GitObject>, GitPackable {
         }
 
         public Iterable<GitObject> GetObjects() {
-            return new TreeSet<>(fItems.values());
+            ArrayDeque<GitObject> objects = new ArrayDeque<>();
+            for (String i: fItemOrder)
+                objects.push(fItems.get(i));
+            return objects;
         }
 
         public Iterable<GitBlob> GetBlobs() {
@@ -175,6 +211,12 @@ public abstract class GitObject implements Comparable<GitObject>, GitPackable {
             return GetFilename() +"/";
         }
 
+        public void SetRealObject(String key, GitObject obj) {
+            if (fItems.containsKey(key)) {
+                fItems.put(key, obj);
+            }
+        }
+
         private void FindAllBlobs(HashMap<String, GitBlob> data) {
             String rootPath = GetPath();
             for (GitBlob i: GetBlobs())
@@ -210,10 +252,12 @@ public abstract class GitObject implements Comparable<GitObject>, GitPackable {
                     newItem = new GitBlob(this, filename, f);
                     fItems.put(filename, newItem);
                 }
+                fItemOrder.push(filename);
             } else if (nextSlash == -1) {
                 Remove(filename);
                 newItem = new GitBlob(this, filename, f);
                 fItems.put(filename, newItem);
+                fItemOrder.push(filename);
             } else {
                 newItem = ((GitTree) obj).AddItem(path.substring(nextSlash + 1), f);
             }
@@ -223,10 +267,40 @@ public abstract class GitObject implements Comparable<GitObject>, GitPackable {
 
         public GitTree Remove(String filename) {
             fItems.remove(filename);
+            fItemOrder.remove(filename);
             fSha1 = null;
             return this;
         }
 
+        public void Fill(byte[] data) {
+            int i = 0;
+
+            while (i < data.length) {
+                byte[] mode = null;
+                int len;
+                for (len =0; i +len <data.length && len < 8; ++len) {
+                    if (data[i + len] == ' ') {
+                        mode = new byte[len];
+                        System.arraycopy(data, i, mode, 0, len);
+                        i += len + 1;
+                        break;
+                    }
+                }
+                if (mode == null)
+                    break;
+                for (len =0; i +len < data.length && data[i +len] != 0; ++len);
+                byte[] filenameBytes = new byte[len];
+                System.arraycopy(data, i, filenameBytes, 0, len);
+                i += len +1;
+                if (i +20 > data.length)
+                    break;
+                byte []sha1 = new byte[20];
+                System.arraycopy(data, i, sha1, 0, 20);
+                i += 20;
+                AddItem(GitObject.factory(this, mode, CharsetHelper.ByteArrayToString(filenameBytes), sha1));
+            }
+        }
+
         @Override
         public eType GetPackableType() {
             return eType.eType_Tree;
@@ -269,7 +343,7 @@ public abstract class GitObject implements Comparable<GitObject>, GitPackable {
         if (mode[0] == '4') {
             return new GitTree(parent, mode, name, sha1);
         }
-        return new GitBlob(parent, mode, name, sha1);
+        return new GitRawData(parent, mode, name, sha1);
     }
 
     public byte[] GetHash() {

app/src/main/java/info/knacki/pass/git/entities/GitPackable.java

@@ -10,6 +10,20 @@ public interface GitPackable {
         eType_RefDelta
     }
 
+    class PackV2Header {
+        public eType type;
+        public int length;
+
+        public PackV2Header() {
+            this(null, 0);
+        }
+
+        public PackV2Header(eType type, int length) {
+            this.type = type;
+            this.length = length;
+        }
+    }
+
     eType GetPackableType();
     byte[] GetPack();
 }

app/src/main/java/info/knacki/pass/git/entities/GitPackableFactory.java

@@ -0,0 +1,27 @@
+package info.knacki.pass.git.entities;
+
+import info.knacki.pass.git.GitSha1;
+import info.knacki.pass.io.CharsetHelper;
+
+public class GitPackableFactory {
+    public static GitPackable build(GitPackable.eType type, String hash, byte[] data) {
+        switch (type) {
+            case eType_Commit:
+                return new GitCommit(hash, CharsetHelper.ByteArrayToString(data));
+
+            case eType_Tree:
+                GitObject.GitTree tree = new GitObject.GitTree(GitSha1.StringToBytes(hash));
+                tree.Initialize().Fill(data);
+                return tree;
+
+            case eType_Blob:
+                return new GitObject.GitRawData(GitSha1.StringToBytes(hash), data);
+
+            case eType_OfsDelta:
+            case eType_RefDelta:
+            case eType_Tag:
+                break;
+        }
+        return null;
+    }
+}

app/src/main/java/info/knacki/pass/git/entities/GitPackableUtil.java

@@ -23,6 +23,24 @@ public class GitPackableUtil {
         return -1;
     }
 
+    public static GitPackable.eType getObjType(int type) {
+        switch (type) {
+            case 1:
+                return GitPackable.eType.eType_Commit;
+            case 2:
+                return GitPackable.eType.eType_Tree;
+            case 3:
+                return GitPackable.eType.eType_Blob;
+            case 4:
+                return GitPackable.eType.eType_Tag;
+            case 6:
+                return GitPackable.eType.eType_OfsDelta;
+            case 7:
+                return GitPackable.eType.eType_RefDelta;
+        }
+        return null;
+    }
+
     public static String GetObjTypeString(GitPackable.eType type) {
         switch (type) {
             case eType_Commit:
@@ -49,10 +67,11 @@ public class GitPackableUtil {
         return nbBits;
     }
 
-    public static byte[] getObjHeader(GitPackable.eType type, long len) {
+    public static byte[] getObjHeader(GitPackable.PackV2Header header) {
+        int len = header.length;
         ByteArrayOutputStream buffer = new ByteArrayOutputStream();
         byte lastByte;
-        lastByte = (byte) ((getObjType(type)) << 4);
+        lastByte = (byte) ((getObjType(header.type)) << 4);
         int nbBitToWrite = bitToWrite(len);
         nbBitToWrite -= 4;
         lastByte |= (byte) (len & 0b1111);

app/src/main/java/info/knacki/pass/io/AppendableInputStream.java

@@ -1,54 +1,68 @@
 package info.knacki.pass.io;
 
-import java.io.IOException;
+import org.bouncycastle.crypto.tls.ByteQueue;
+
 import java.io.InputStream;
 import java.io.OutputStream;
-import java.util.ArrayDeque;
-import java.util.logging.Level;
-import java.util.logging.Logger;
 
 public class AppendableInputStream extends InputStream {
-    private final static Logger log = Logger.getLogger(AppendableInputStream.class.getName());
-    private ArrayDeque<Integer> buffer;
-    private OutputStream fWriter = new OutputStream() {
+    private boolean fClosed;
+    private final ByteQueue buffer;
+    private final Writer fWriter;
+
+    public class Writer extends OutputStream {
         @Override
         public void write(int b) {
-            buffer.push(b);
+            buffer.addData(new byte[] {(byte) (b & 0xFF)}, 0, 1);
+        }
+
+        public void AddBytes(byte[] bytes) {
+            buffer.addData(bytes, 0, bytes.length);
         }
-    };
+
+        public void close() {
+            fClosed = true;
+        }
+    }
 
     public AppendableInputStream() {
-        buffer = new ArrayDeque<>(256);
+        buffer = new ByteQueue(256);
+        fWriter = this.new Writer();
+        fClosed = false;
     }
 
-    public OutputStream GetWriter() {
+    public Writer GetWriter() {
         return fWriter;
     }
 
     @Override
     public int read() {
-        while (buffer.isEmpty()) {
-            try {
-                Thread.sleep(500);
-            }
-            catch (InterruptedException e) {
-                log.log(Level.WARNING, "Interrupted while waiting for available bytes", e);
-                return 0;
-            }
-        }
-        return buffer.pop();
+        if (buffer.available() > 0)
+            return buffer.removeData(1, 0)[0] & 0xFF;
+        return -1;
+    }
+
+    @Override
+    public int read(byte[] b) {
+        return read(b, 0, b.length);
+    }
+
+    @Override
+    public int read(byte[] b, int off, int len) {
+        if (fClosed)
+            return 0;
+        int maxRead = Math.min(len, available());
+        buffer.removeData(b, off, maxRead, 0);
+        return maxRead;
     }
 
     @Override
     public int available() {
-        return buffer.size();
+        return fClosed ? 0 : buffer.available();
     }
 
-    public void closeUnsafe() {
-        try {
-            close();
-        } catch (IOException e) {
-            log.log(Level.WARNING, "Cannot close stream", e);
-        }
+    @Override
+    public void close() {
+        fWriter.close();
     }
 }

app/src/main/java/info/knacki/pass/io/CharsetHelper.java

@@ -14,12 +14,12 @@ public class CharsetHelper {
 
     public static String ByteArrayToString(byte[] arr, int offset, int len) {
         try {
-            return new String(arr, offset, len, DEFAULT_CHARSET);
+            return new String(arr, offset, Math.min(len, arr.length -offset), DEFAULT_CHARSET);
         }
         catch (UnsupportedEncodingException e) {
             log.severe("Unsupported charset " +DEFAULT_CHARSET);
         }
-        return new String(arr, offset, len, Charset.defaultCharset());
+        return new String(arr, offset, Math.min(len, arr.length -offset), Charset.defaultCharset());
     }
 
     public static byte[] StringToByteArray(String str) {

app/src/main/java/info/knacki/pass/io/ssh/JSchWrapper.java

@@ -30,7 +30,7 @@ public class JSchWrapper extends AsyncTask<InputStream, Void, Void> implements S
 
     private ChannelExec fChannel = null;
 
-    JSchWrapper(ConnectionParams config, String command) {
+    public JSchWrapper(ConnectionParams config, String command) {
         fCommand = command;
         fAuth = config;
     }
@@ -89,7 +89,7 @@ public class JSchWrapper extends AsyncTask<InputStream, Void, Void> implements S
             // Connection settings
             JSch connection = new JSch();
             String privateKey = fAuth.GetPrivateKey();
-            Session session = connection.getSession(fAuth.GetUser(), fAuth.GetUrl()); // FIXME only host !
+            Session session = connection.getSession(fAuth.GetUser(), fAuth.GetHostname());
             session.setConfig("StrictHostKeyChecking", "no"); // FIXME
             if (privateKey != null && !privateKey.isEmpty()) {
                 connection.addIdentity(privateKey); // FIXME key passphrase

app/src/main/java/info/knacki/pass/io/ssh/SSHConnection.java

@@ -11,7 +11,7 @@ public interface SSHConnection {
     }
 
     interface ConnectionParams extends NetworkUtils.AuthConfig {
-        String GetUrl();
+        String GetHostname();
     }
 
     SSHConnection SetOnConnectionReadyListener(OnConnectionReady listener);

app/src/main/java/info/knacki/pass/settings/SettingsManager.java

@@ -13,7 +13,6 @@ import java.util.logging.Logger;
 
 import info.knacki.pass.io.NetworkUtils;
 import info.knacki.pass.io.PathUtils;
-import info.knacki.pass.io.ssh.SSHConnection;
 
 public class SettingsManager {
     private static final Logger log = Logger.getLogger(SettingsManager.class.getName());
@@ -60,7 +59,7 @@ public class SettingsManager {
         public abstract String GetData();
     }
 
-    public static class Git extends VCS implements NetworkUtils.AuthConfig, SSHConnection.ConnectionParams {
+    public static class Git extends VCS implements NetworkUtils.AuthConfig {
         String fUrl;
         String fUser;
         String fPassword;
@@ -143,7 +142,6 @@ public class SettingsManager {
             return fUrl;
         }
 
-        @Override
         public String GetUrl() {
             return fUrl;
         }

app/src/main/java/info/knacki/pass/settings/ui/SettingsActivity.java

@@ -440,10 +440,24 @@ public class SettingsActivity extends AppCompatPreferenceActivity {
             }
         }
 
+        protected void clearBranches(final ListPreference gitBranches) {
+            gitBranches.setEntryValues(new CharSequence[]{});
+            gitBranches.setEntries(new CharSequence[]{});
+            gitBranches.setEnabled(false);
+        }
+
         protected void populateBranches(final ListPreference gitBranches, final SettingsManager.Git versioning) {
             gitBranches.setEnabled(false);
-            GitInterface gitInterface = GitInterfaceFactory.factory(versioning);
-            if (gitInterface != null) {
+            if (versioning != null) {
+                GitInterface gitInterface;
+                try {
+                    gitInterface = GitInterfaceFactory.factory(versioning);
+                }
+                catch (GitInterfaceFactory.GitInterfaceException e) {
+                    Toast.makeText(getActivity(), e.getMessage(), Toast.LENGTH_LONG).show();
+                    clearBranches(gitBranches);
+                    return;
+                }
                 gitInterface.GetRefs(new OnResponseListener<GitRef[]>() {
                     @Override
                     public void OnResponse(final GitRef[] result) {
@@ -474,9 +488,7 @@ public class SettingsActivity extends AppCompatPreferenceActivity {
                     }
                 });
             } else {
-                gitBranches.setEntryValues(new CharSequence[]{});
-                gitBranches.setEntries(new CharSequence[]{});
-                gitBranches.setEnabled(false);
+                clearBranches(gitBranches);
             }
         }
 

app/src/main/java/info/knacki/pass/ui/GitPullActivity.java

@@ -62,8 +62,8 @@ public class GitPullActivity extends AppCompatActivity {
             return;
         }
         LOCAL_GIT_HASH_VERSION_FILE = PathUtils.GetGitFile(this);
-        fGitInterface = GitInterfaceFactory.factory((SettingsManager.Git) versioning);
-        if (fGitInterface != null) {
+        try {
+            fGitInterface = GitInterfaceFactory.factory((SettingsManager.Git) versioning);
             fGitInterface.FetchHead(new OnStreamResponseListener<GitCommit>() {
                 @Override
                 public void OnMsg(final String msg) {
@@ -79,16 +79,16 @@ public class GitPullActivity extends AppCompatActivity {
                 @Override
                 public void OnError(final String msg, Throwable e) {
                     GitPullActivity.this.runOnUiThread(() -> {
-                        ProgressBar pg = findViewById(R.id.progressBar);
-                        pg.setIndeterminate(false);
-                        pg.setMax(1);
-                        pg.setProgress(1);
-                        TextView logView = findViewById(R.id.logView);
-                        logView.append(msg +"\n");
-                        findViewById(R.id.close_bt).setEnabled(true);
+                        OnMsg(msg);
+                        FinishLoading();
                     });
                 }
             });
+        } catch (GitInterfaceFactory.GitInterfaceException e) {
+            GitPullActivity.this.runOnUiThread(() -> {
+                OnMsg(e.getMessage());
+                FinishLoading();
+            });
         }
         findViewById(R.id.close_bt).setOnClickListener(v -> GitPullActivity.this.finish());
     }
@@ -194,30 +194,28 @@ public class GitPullActivity extends AppCompatActivity {
                 RmEmptyDirs(i, false);
     }
 
+    void FinishLoading() {
+        ProgressBar pg = findViewById(R.id.progressBar);
+        pg.setIndeterminate(false);
+        pg.setMax(1);
+        pg.setProgress(1);
+        RmEmptyDirs(new File(PathUtils.GetPassDir(GitPullActivity.this)), true);
+        findViewById(R.id.close_bt).setEnabled(true);
+    }
+
     void SyncFiles(final GitLocal localVersion, final HashMap<String, GitObject.GitBlob> filesToPull, final Set<String> filesToPush) {
         final OnStreamResponseListener<Void> allDone = new OnStreamResponseListener<Void>() {
             @Override
             public void OnResponse(Void result) {
                 GitPullActivity.this.runOnUiThread(() -> {
-                    ProgressBar pg = findViewById(R.id.progressBar);
-                    pg.setIndeterminate(false);
-                    pg.setMax(1);
-                    pg.setProgress(1);
                     localVersion.Write(new File(LOCAL_GIT_HASH_VERSION_FILE));
-                    RmEmptyDirs(new File(PathUtils.GetPassDir(GitPullActivity.this)), true);
-                    findViewById(R.id.close_bt).setEnabled(true);
+                    FinishLoading();
                 });
             }
 
             @Override
             public void OnError(String msg, Throwable e) {
-                GitPullActivity.this.runOnUiThread(() -> {
-                    ProgressBar pg = findViewById(R.id.progressBar);
-                    pg.setIndeterminate(false);
-                    pg.setMax(1);
-                    pg.setProgress(1);
-                    findViewById(R.id.close_bt).setEnabled(true);
-                });
+                GitPullActivity.this.runOnUiThread(() -> FinishLoading());
             }
 
             @Override
@@ -241,7 +239,7 @@ public class GitPullActivity extends AppCompatActivity {
             afterFetching.run();
         } else {
             OnMsg("Updating local repository");
-            DownloadBlobs(filesToPull, localVersion, new OnResponseListener<Void>() {
+            DownloadBlobs(filesToPull, localVersion, new OnStreamResponseListener<Void>() {
                 @Override
                 public void OnResponse(Void result) {
                     afterFetching.run();
@@ -251,11 +249,16 @@ public class GitPullActivity extends AppCompatActivity {
                 public void OnError(String msg, Throwable e) {
                     allDone.OnError(msg, e);
                 }
+
+                @Override
+                public void OnMsg(String message) {
+                    OnMsg(message);
+                }
             });
         }
     }
 
-    void DownloadBlobs(Map<String, GitObject.GitBlob> blobs, final GitLocal localVersion, final OnResponseListener<Void> resp) {
+    void DownloadBlobs(Map<String, GitObject.GitBlob> blobs, final GitLocal localVersion, final OnStreamResponseListener<Void> resp) {
         if (blobs.size() == 0) {
             resp.OnResponse(null);
             return;
@@ -266,12 +269,12 @@ public class GitPullActivity extends AppCompatActivity {
             logView.append(" > " +i +"\n");
         final Stack<Map.Entry<String, GitObject.GitBlob>> files = new Stack<>();
         files.addAll(blobs.entrySet());
-        final OnResponseListener<byte[]> downloader = new OnResponseListener<byte[]>() {
+        final OnStreamResponseListener<byte[]> downloader = new OnStreamResponseListener<byte[]>() {
             @Override
             public void OnResponse(final byte[] result) {
                 final String filename = files.peek().getKey();
                 final GitObject.GitBlob blob = files.peek().getValue();
-                final OnResponseListener<byte[]> _this = this;
+                final OnStreamResponseListener<byte[]> _this = this;
 
                 GitPullActivity.this.runOnUiThread(() -> {
                     WriteFile(filename, localVersion, blob, result);
@@ -294,12 +297,17 @@ public class GitPullActivity extends AppCompatActivity {
                     resp.OnResponse(null);
                 }
             }
+
+            @Override
+            public void OnMsg(String message) {
+                resp.OnMsg(message);
+            }
         };
 
         DownloadNext(files, localVersion, downloader, resp);
     }
 
-    void DownloadNext(Stack<Map.Entry<String, GitObject.GitBlob>> files, GitLocal localCache, OnResponseListener<byte[]> downloader, OnResponseListener<Void> resp) {
+    void DownloadNext(Stack<Map.Entry<String, GitObject.GitBlob>> files, GitLocal localCache, OnStreamResponseListener<byte[]> downloader, OnResponseListener<Void> resp) {
         if (!files.empty()) {
             if (files.peek().getValue() == null) {
                 // remove file

app/src/main/java/info/knacki/pass/ui/MainActivity.java

@@ -20,9 +20,6 @@ import java.util.logging.Logger;
 import info.knacki.pass.R;
 import info.knacki.pass.generator.PasswordGenerator;
 import info.knacki.pass.generator.ui.PasswordGeneratorWizard;
-import info.knacki.pass.git.GitInterface;
-import info.knacki.pass.git.GitInterfaceFactory;
-import info.knacki.pass.git.entities.GitRef;
 import info.knacki.pass.io.FileInterfaceFactory;
 import info.knacki.pass.io.FileUtils;
 import info.knacki.pass.io.IFileInterface;
@@ -128,20 +125,7 @@ public class MainActivity extends AppCompatActivity implements PasswordEditListe
 
         requestPermissions();
 
-        GitInterface gitInterface = GitInterfaceFactory.factory((SettingsManager.Git) SettingsManager.GetVCS(this));
-        if (gitInterface != null) {
-            gitInterface.GetRefs(new OnResponseListener<GitRef[]>() {
-                @Override
-                public void OnResponse(GitRef[] result) {
-
-                }
-
-                @Override
-                public void OnError(String msg, Throwable e) {
-
-                }
-            });
-        }
+        startActivity(new Intent(this, GitPullActivity.class));
     }
 
     @Override