James Moger
2011-06-25 22fc5e48cbe050d8485f78f6165b59e4085eaeef
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
/*
 * Copyright 2011 gitblit.com.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.gitblit;
 
import java.text.MessageFormat;
 
import com.gitblit.Constants.AccessRestrictionType;
import com.gitblit.models.RepositoryModel;
import com.gitblit.models.UserModel;
import com.gitblit.utils.StringUtils;
 
public class GitFilter extends AccessRestrictionFilter {
 
    protected final String gitReceivePack = "/git-receive-pack";
 
    protected final String gitUploadPack = "/git-upload-pack";
 
    protected final String[] suffixes = { gitReceivePack, gitUploadPack, "/info/refs", "/HEAD",
            "/objects" };
 
    @Override
    protected String extractRepositoryName(String url) {
        String repository = url;
        for (String urlSuffix : suffixes) {
            if (repository.indexOf(urlSuffix) > -1) {
                repository = repository.substring(0, repository.indexOf(urlSuffix));
            }
        }
        return repository;
    }
 
    @Override
    protected String getUrlRequestType(String suffix) {
        if (!StringUtils.isEmpty(suffix)) {
            if (suffix.startsWith(gitReceivePack)) {
                return gitReceivePack;
            } else if (suffix.startsWith(gitUploadPack)) {
                return gitUploadPack;
            } else if (suffix.contains("?service=git-receive-pack")) {
                return gitReceivePack;
            } else if (suffix.contains("?service=git-upload-pack")) {
                return gitUploadPack;
            }
        }
        return null;
    }
 
    @Override
    protected boolean requiresAuthentication(RepositoryModel repository) {
        return repository.accessRestriction.atLeast(AccessRestrictionType.PUSH);
    }
 
    @Override
    protected boolean canAccess(RepositoryModel repository, UserModel user, String urlRequestType) {
        if (!GitBlit.getBoolean(Keys.git.enableGitServlet, true)) {
            // Git Servlet disabled
            return false;
        }
        if (repository.isFrozen || repository.accessRestriction.atLeast(AccessRestrictionType.PUSH)) {
            boolean authorizedUser = user.canAccessRepository(repository.name);
            if (urlRequestType.equals(gitReceivePack)) {
                // Push request
                if (!repository.isFrozen && authorizedUser) {
                    // clone-restricted or push-authorized
                    return true;
                } else {
                    // user is unauthorized to push to this repository
                    logger.warn(MessageFormat.format("user {0} is not authorized to push to {1}",
                            user.username, repository));
                    return false;
                }
            } else if (urlRequestType.equals(gitUploadPack)) {
                // Clone request
                boolean cloneRestricted = repository.accessRestriction
                        .atLeast(AccessRestrictionType.CLONE);
                if (!cloneRestricted || (cloneRestricted && authorizedUser)) {
                    // push-restricted or clone-authorized
                    return true;
                } else {
                    // user is unauthorized to clone this repository
                    logger.warn(MessageFormat.format("user {0} is not authorized to clone {1}",
                            user.username, repository));
                    return false;
                }
            }
        }
        return true;
    }
}