Do not traverse unaccessible subdirectories (issue 51)

lemval

2012-01-31 1c30dad2115fc513791d8a5b292ad0f7d7b85749

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
package com.gitblit.tests; 
 
import static org.junit.Assert.assertFalse; 
import static org.junit.Assert.assertTrue; 
 
import java.io.BufferedWriter; 
import java.io.File; 
import java.io.FileOutputStream; 
import java.io.OutputStreamWriter; 
import java.text.MessageFormat; 
import java.util.Date; 
import java.util.concurrent.atomic.AtomicBoolean; 
 
import org.eclipse.jgit.api.CloneCommand; 
import org.eclipse.jgit.api.Git; 
import org.eclipse.jgit.transport.UsernamePasswordCredentialsProvider; 
import org.eclipse.jgit.util.FileUtils; 
import org.junit.AfterClass; 
import org.junit.BeforeClass; 
import org.junit.Test; 
 
import com.gitblit.Constants.AccessRestrictionType; 
import com.gitblit.GitBlit; 
import com.gitblit.models.RepositoryModel; 
 
public class GitServletTest { 
 
    static File ticgitFolder = new File(GitBlitSuite.REPOSITORIES, "working/ticgit"); 
     
    static File ticgit2Folder = new File(GitBlitSuite.REPOSITORIES, "working/ticgit2"); 
 
    static File jgitFolder = new File(GitBlitSuite.REPOSITORIES, "working/jgit"); 
 
    String url = GitBlitSuite.url; 
    String account = GitBlitSuite.account; 
    String password = GitBlitSuite.password; 
 
    private static final AtomicBoolean started = new AtomicBoolean(false); 
 
    @BeforeClass 
    public static void startGitblit() throws Exception { 
        deleteWorkingFolders(); 
        started.set(GitBlitSuite.startGitblit()); 
    } 
 
    @AfterClass 
    public static void stopGitblit() throws Exception { 
        if (started.get()) { 
            GitBlitSuite.stopGitblit(); 
        } 
        deleteWorkingFolders(); 
    } 
     
    private static void deleteWorkingFolders() throws Exception { 
        if (ticgitFolder.exists()) { 
            FileUtils.delete(ticgitFolder, FileUtils.RECURSIVE); 
        } 
        if (ticgit2Folder.exists()) { 
            FileUtils.delete(ticgit2Folder, FileUtils.RECURSIVE); 
        } 
        if (jgitFolder.exists()) { 
            FileUtils.delete(jgitFolder, FileUtils.RECURSIVE); 
        } 
    } 
 
    @Test 
    public void testClone() throws Exception { 
        CloneCommand clone = Git.cloneRepository(); 
        clone.setURI(MessageFormat.format("{0}/git/ticgit.git", url)); 
        clone.setDirectory(ticgitFolder); 
        clone.setBare(false); 
        clone.setCloneAllBranches(true); 
        clone.setCredentialsProvider(new UsernamePasswordCredentialsProvider(account, password)); 
        close(clone.call());         
        assertTrue(true); 
    } 
 
    @Test 
    public void testBogusLoginClone() throws Exception { 
        // restrict repository access 
        RepositoryModel model = GitBlit.self().getRepositoryModel("ticgit.git"); 
        model.accessRestriction = AccessRestrictionType.CLONE; 
        GitBlit.self().updateRepositoryModel(model.name, model, false); 
 
        // delete any existing working folder         
        boolean cloned = false; 
        try { 
            CloneCommand clone = Git.cloneRepository(); 
            clone.setURI(MessageFormat.format("{0}/git/ticgit.git", url)); 
            clone.setDirectory(ticgit2Folder); 
            clone.setBare(false); 
            clone.setCloneAllBranches(true); 
            clone.setCredentialsProvider(new UsernamePasswordCredentialsProvider("bogus", "bogus")); 
            close(clone.call()); 
            cloned = true; 
        } catch (Exception e) { 
            // swallow the exception which we expect 
        } 
 
        // restore anonymous repository access 
        model.accessRestriction = AccessRestrictionType.NONE; 
        GitBlit.self().updateRepositoryModel(model.name, model, false); 
 
        assertFalse("Bogus login cloned a repository?!", cloned); 
    } 
 
    @Test 
    public void testAnonymousPush() throws Exception { 
        Git git = Git.open(ticgitFolder); 
        File file = new File(ticgitFolder, "TODO"); 
        OutputStreamWriter os = new OutputStreamWriter(new FileOutputStream(file, true)); 
        BufferedWriter w = new BufferedWriter(os); 
        w.write("// " + new Date().toString() + "\n"); 
        w.close(); 
        git.add().addFilepattern(file.getName()).call(); 
        git.commit().setMessage("test commit").call(); 
        git.push().setPushAll().call(); 
        close(git); 
    } 
 
    @Test 
    public void testSubfolderPush() throws Exception { 
        CloneCommand clone = Git.cloneRepository(); 
        clone.setURI(MessageFormat.format("{0}/git/test/jgit.git", url)); 
        clone.setDirectory(jgitFolder); 
        clone.setBare(false); 
        clone.setCloneAllBranches(true); 
        clone.setCredentialsProvider(new UsernamePasswordCredentialsProvider(account, password)); 
        close(clone.call()); 
        assertTrue(true); 
 
        Git git = Git.open(jgitFolder); 
        File file = new File(jgitFolder, "TODO"); 
        OutputStreamWriter os = new OutputStreamWriter(new FileOutputStream(file, true)); 
        BufferedWriter w = new BufferedWriter(os); 
        w.write("// " + new Date().toString() + "\n"); 
        w.close(); 
        git.add().addFilepattern(file.getName()).call(); 
        git.commit().setMessage("test commit").call(); 
        git.push().setPushAll().call(); 
        close(git); 
    } 
     
    private void close(Git git) { 
        // really close the repository 
        // decrement the use counter to 0 
        for (int i = 0; i < 2; i++) { 
            git.getRepository().close(); 
        } 
    } 
}