2014-04-16 02:37:07 -06:00
// Copyright 2014 The Gogs Authors. All rights reserved.
2019-04-25 16:42:50 -06:00
// Copyright 2019 The Gitea Authors. All rights reserved.
2014-04-16 02:37:07 -06:00
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file.
2014-04-10 12:20:58 -06:00
package repo
import (
2014-04-10 20:27:13 -06:00
"bytes"
2014-10-15 14:28:38 -06:00
"compress/gzip"
2014-04-10 12:20:58 -06:00
"fmt"
"net/http"
"os"
"os/exec"
"path"
"regexp"
"strconv"
"strings"
"time"
2016-11-10 09:24:48 -07:00
"code.gitea.io/gitea/models"
2019-04-25 16:42:50 -06:00
"code.gitea.io/gitea/modules/auth"
2016-11-10 09:24:48 -07:00
"code.gitea.io/gitea/modules/base"
"code.gitea.io/gitea/modules/context"
2019-06-26 12:15:26 -06:00
"code.gitea.io/gitea/modules/git"
2016-11-10 09:24:48 -07:00
"code.gitea.io/gitea/modules/log"
"code.gitea.io/gitea/modules/setting"
2017-12-10 21:37:04 -07:00
"code.gitea.io/gitea/modules/util"
2014-04-10 12:20:58 -06:00
)
2016-11-24 00:04:31 -07:00
// HTTP implmentation git smart HTTP protocol
2016-03-11 09:56:52 -07:00
func HTTP ( ctx * context . Context ) {
2019-01-14 14:05:27 -07:00
if len ( setting . Repository . AccessControlAllowOrigin ) > 0 {
2019-01-15 21:16:45 -07:00
allowedOrigin := setting . Repository . AccessControlAllowOrigin
2019-01-14 14:05:27 -07:00
// Set CORS headers for browser-based git clients
2019-01-15 21:16:45 -07:00
ctx . Resp . Header ( ) . Set ( "Access-Control-Allow-Origin" , allowedOrigin )
2019-01-14 14:05:27 -07:00
ctx . Resp . Header ( ) . Set ( "Access-Control-Allow-Headers" , "Content-Type, Authorization, User-Agent" )
// Handle preflight OPTIONS request
if ctx . Req . Method == "OPTIONS" {
2019-01-15 21:16:45 -07:00
if allowedOrigin == "*" {
ctx . Status ( http . StatusOK )
} else if allowedOrigin == "null" {
ctx . Status ( http . StatusForbidden )
} else {
origin := ctx . Req . Header . Get ( "Origin" )
if len ( origin ) > 0 && origin == allowedOrigin {
ctx . Status ( http . StatusOK )
} else {
ctx . Status ( http . StatusForbidden )
}
}
2019-01-14 14:05:27 -07:00
return
}
}
2014-07-25 22:24:27 -06:00
username := ctx . Params ( ":username" )
2015-11-30 18:45:55 -07:00
reponame := strings . TrimSuffix ( ctx . Params ( ":reponame" ) , ".git" )
2017-04-20 20:43:29 -06:00
if ctx . Query ( "go-get" ) == "1" {
2017-09-23 07:24:24 -06:00
context . EarlyResponseForGoGetMeta ( ctx )
2017-04-20 20:43:29 -06:00
return
}
2014-04-10 12:20:58 -06:00
var isPull bool
service := ctx . Query ( "service" )
if service == "git-receive-pack" ||
strings . HasSuffix ( ctx . Req . URL . Path , "git-receive-pack" ) {
isPull = false
} else if service == "git-upload-pack" ||
strings . HasSuffix ( ctx . Req . URL . Path , "git-upload-pack" ) {
isPull = true
2017-02-21 08:02:10 -07:00
} else if service == "git-upload-archive" ||
strings . HasSuffix ( ctx . Req . URL . Path , "git-upload-archive" ) {
isPull = true
2014-04-10 12:20:58 -06:00
} else {
isPull = ( ctx . Req . Method == "GET" )
}
2017-02-21 08:02:10 -07:00
var accessMode models . AccessMode
if isPull {
accessMode = models . AccessModeRead
} else {
accessMode = models . AccessModeWrite
}
2015-11-30 18:45:55 -07:00
isWiki := false
2017-05-18 08:54:24 -06:00
var unitType = models . UnitTypeCode
2015-11-30 18:45:55 -07:00
if strings . HasSuffix ( reponame , ".wiki" ) {
isWiki = true
2017-05-18 08:54:24 -06:00
unitType = models . UnitTypeWiki
2017-02-25 07:54:40 -07:00
reponame = reponame [ : len ( reponame ) - 5 ]
2015-11-30 18:45:55 -07:00
}
2019-04-24 23:51:40 -06:00
owner , err := models . GetUserByName ( username )
2014-04-10 12:20:58 -06:00
if err != nil {
2019-04-24 23:51:40 -06:00
ctx . NotFoundOrServerError ( "GetUserByName" , models . IsErrUserNotExist , err )
return
}
repo , err := models . GetRepositoryByName ( owner . ID , reponame )
if err != nil {
if models . IsErrRepoNotExist ( err ) {
redirectRepoID , err := models . LookupRepoRedirect ( owner . ID , reponame )
if err == nil {
context . RedirectToRepo ( ctx , redirectRepoID )
} else {
ctx . NotFoundOrServerError ( "GetRepositoryByName" , models . IsErrRepoRedirectNotExist , err )
}
} else {
ctx . ServerError ( "GetRepositoryByName" , err )
}
2014-04-10 12:20:58 -06:00
return
}
2019-01-23 11:58:38 -07:00
// Don't allow pushing if the repo is archived
if repo . IsArchived && ! isPull {
ctx . HandleText ( http . StatusForbidden , "This repo is archived. You can view files and clone it, but cannot push or open issues/pull-requests." )
return
}
2015-02-07 13:47:23 -07:00
// Only public pull don't need auth.
2014-04-16 02:45:02 -06:00
isPublicPull := ! repo . IsPrivate && isPull
2015-02-07 13:47:23 -07:00
var (
askAuth = ! isPublicPull || setting . Service . RequireSignInView
authUser * models . User
authUsername string
authPasswd string
2017-02-25 07:54:40 -07:00
environ [ ] string
2015-02-07 13:47:23 -07:00
)
2014-04-10 20:27:13 -06:00
2014-04-10 12:20:58 -06:00
// check access
if askAuth {
2018-08-29 08:39:16 -06:00
authUsername = ctx . Req . Header . Get ( setting . ReverseProxyAuthUser )
if setting . Service . EnableReverseProxyAuth && len ( authUsername ) > 0 {
2016-12-28 14:33:59 -07:00
authUser , err = models . GetUserByName ( authUsername )
2015-02-07 13:47:23 -07:00
if err != nil {
2016-12-28 14:33:59 -07:00
ctx . HandleText ( 401 , "reverse proxy login error, got error while running GetUserByName" )
2015-02-07 13:47:23 -07:00
return
2015-01-08 07:16:38 -07:00
}
2016-12-30 00:26:05 -07:00
} else {
2016-12-28 14:33:59 -07:00
authHead := ctx . Req . Header . Get ( "Authorization" )
if len ( authHead ) == 0 {
ctx . Resp . Header ( ) . Set ( "WWW-Authenticate" , "Basic realm=\".\"" )
ctx . Error ( http . StatusUnauthorized )
return
2015-08-18 16:22:33 -06:00
}
2016-12-28 14:33:59 -07:00
auths := strings . Fields ( authHead )
// currently check basic auth
// TODO: support digit auth
// FIXME: middlewares/context.go did basic auth check already,
// maybe could use that one.
if len ( auths ) != 2 || auths [ 0 ] != "Basic" {
ctx . HandleText ( http . StatusUnauthorized , "no basic auth and digit auth" )
return
}
authUsername , authPasswd , err = base . BasicAuthDecode ( auths [ 1 ] )
2015-02-07 13:47:23 -07:00
if err != nil {
2016-12-28 14:33:59 -07:00
ctx . HandleText ( http . StatusUnauthorized , "no basic auth and digit auth" )
2015-01-08 07:16:38 -07:00
return
}
2014-04-10 12:20:58 -06:00
2019-02-12 02:20:08 -07:00
// Check if username or password is a token
isUsernameToken := len ( authPasswd ) == 0 || authPasswd == "x-oauth-basic"
// Assume username is token
authToken := authUsername
if ! isUsernameToken {
// Assume password is token
authToken = authPasswd
2017-07-26 01:33:16 -06:00
}
2019-04-25 16:42:50 -06:00
uid := auth . CheckOAuthAccessToken ( authToken )
if uid != 0 {
ctx . Data [ "IsApiToken" ] = true
authUser , err = models . GetUserByID ( uid )
if err != nil {
ctx . ServerError ( "GetUserByID" , err )
return
}
}
2019-02-12 02:20:08 -07:00
// Assume password is a token.
token , err := models . GetAccessTokenBySHA ( authToken )
if err == nil {
if isUsernameToken {
authUser , err = models . GetUserByID ( token . UID )
if err != nil {
ctx . ServerError ( "GetUserByID" , err )
return
}
} else {
2017-10-15 09:35:43 -06:00
authUser , err = models . GetUserByName ( authUsername )
if err != nil {
if models . IsErrUserNotExist ( err ) {
ctx . HandleText ( http . StatusUnauthorized , "invalid credentials" )
} else {
2018-01-10 14:34:17 -07:00
ctx . ServerError ( "GetUserByName" , err )
2017-10-15 09:35:43 -06:00
}
return
2017-07-26 01:33:16 -06:00
}
2019-02-12 02:20:08 -07:00
if authUser . ID != token . UID {
2017-07-26 01:33:16 -06:00
ctx . HandleText ( http . StatusUnauthorized , "invalid credentials" )
2019-02-12 02:20:08 -07:00
return
2016-12-28 14:33:59 -07:00
}
}
2019-02-12 02:20:08 -07:00
token . UpdatedUnix = util . TimeStampNow ( )
if err = models . UpdateAccessToken ( token ) ; err != nil {
ctx . ServerError ( "UpdateAccessToken" , err )
}
2019-06-12 13:41:28 -06:00
} else if ! models . IsErrAccessTokenNotExist ( err ) && ! models . IsErrAccessTokenEmpty ( err ) {
log . Error ( "GetAccessTokenBySha: %v" , err )
2019-02-12 02:20:08 -07:00
}
2017-07-26 01:33:16 -06:00
2019-02-12 02:20:08 -07:00
if authUser == nil {
// Check username and password
authUser , err = models . UserSignIn ( authUsername , authPasswd )
if err != nil {
if ! models . IsErrUserNotExist ( err ) {
ctx . ServerError ( "UserSignIn error: %v" , err )
2017-10-15 09:35:43 -06:00
return
}
2019-02-12 02:20:08 -07:00
}
if authUser == nil {
2017-07-26 01:33:16 -06:00
ctx . HandleText ( http . StatusUnauthorized , "invalid credentials" )
return
}
_ , err = models . GetTwoFactorByUID ( authUser . ID )
if err == nil {
// TODO: This response should be changed to "invalid credentials" for security reasons once the expectation behind it (creating an app token to authenticate) is properly documented
ctx . HandleText ( http . StatusUnauthorized , "Users with two-factor authentication enabled cannot perform HTTP/HTTPS operations via plain username and password. Please create and use a personal access token on the user settings page" )
return
} else if ! models . IsErrTwoFactorNotEnrolled ( err ) {
2018-01-10 14:34:17 -07:00
ctx . ServerError ( "IsErrTwoFactorNotEnrolled" , err )
2016-12-28 14:33:59 -07:00
return
}
2014-04-16 02:45:02 -06:00
}
2018-03-28 19:39:51 -06:00
}
2014-04-10 12:20:58 -06:00
2018-11-28 04:26:14 -07:00
perm , err := models . GetUserRepoPermission ( repo , authUser )
if err != nil {
ctx . ServerError ( "GetUserRepoPermission" , err )
return
}
2018-03-28 19:39:51 -06:00
2018-11-28 04:26:14 -07:00
if ! perm . CanAccess ( accessMode , unitType ) {
ctx . HandleText ( http . StatusForbidden , "User permission denied" )
return
2014-04-10 12:20:58 -06:00
}
2018-11-28 04:26:14 -07:00
if ! isPull && repo . IsMirror {
ctx . HandleText ( http . StatusForbidden , "mirror repository is read-only" )
2017-05-18 08:54:24 -06:00
return
}
2017-02-25 07:54:40 -07:00
environ = [ ] string {
models . EnvRepoUsername + "=" + username ,
models . EnvRepoName + "=" + reponame ,
models . EnvPusherName + "=" + authUser . Name ,
models . EnvPusherID + fmt . Sprintf ( "=%d" , authUser . ID ) ,
models . ProtectedBranchRepoID + fmt . Sprintf ( "=%d" , repo . ID ) ,
2015-11-30 18:45:55 -07:00
}
2018-07-26 10:38:55 -06:00
if ! authUser . KeepEmailPrivate {
environ = append ( environ , models . EnvPusherEmail + "=" + authUser . Email )
}
2017-02-25 07:54:40 -07:00
if isWiki {
environ = append ( environ , models . EnvRepoIsWiki + "=true" )
} else {
environ = append ( environ , models . EnvRepoIsWiki + "=false" )
2017-02-21 08:02:10 -07:00
}
}
2016-06-01 05:19:01 -06:00
HTTPBackend ( ctx , & serviceConfig {
UploadPack : true ,
ReceivePack : true ,
2017-02-25 07:54:40 -07:00
Env : environ ,
2015-03-11 23:15:01 -06:00
} ) ( ctx . Resp , ctx . Req . Request )
2014-04-10 12:20:58 -06:00
}
2016-06-01 05:19:01 -06:00
type serviceConfig struct {
UploadPack bool
ReceivePack bool
2017-02-25 07:54:40 -07:00
Env [ ] string
2014-04-10 12:20:58 -06:00
}
2016-06-01 05:19:01 -06:00
type serviceHandler struct {
2017-02-25 07:54:40 -07:00
cfg * serviceConfig
w http . ResponseWriter
r * http . Request
dir string
file string
environ [ ] string
2016-06-01 05:19:01 -06:00
}
func ( h * serviceHandler ) setHeaderNoCache ( ) {
h . w . Header ( ) . Set ( "Expires" , "Fri, 01 Jan 1980 00:00:00 GMT" )
h . w . Header ( ) . Set ( "Pragma" , "no-cache" )
h . w . Header ( ) . Set ( "Cache-Control" , " no - cache , max - age = 0 , must - revalidate " )
}
func ( h * serviceHandler ) setHeaderCacheForever ( ) {
now := time . Now ( ) . Unix ( )
expires := now + 31536000
h . w . Header ( ) . Set ( "Date" , fmt . Sprintf ( "%d" , now ) )
h . w . Header ( ) . Set ( "Expires" , fmt . Sprintf ( "%d" , expires ) )
h . w . Header ( ) . Set ( "Cache-Control" , "public, max-age=31536000" )
}
func ( h * serviceHandler ) sendFile ( contentType string ) {
reqFile := path . Join ( h . dir , h . file )
fi , err := os . Stat ( reqFile )
if os . IsNotExist ( err ) {
h . w . WriteHeader ( http . StatusNotFound )
return
}
h . w . Header ( ) . Set ( "Content-Type" , contentType )
h . w . Header ( ) . Set ( "Content-Length" , fmt . Sprintf ( "%d" , fi . Size ( ) ) )
h . w . Header ( ) . Set ( "Last-Modified" , fi . ModTime ( ) . Format ( http . TimeFormat ) )
http . ServeFile ( h . w , h . r , reqFile )
2014-04-10 12:20:58 -06:00
}
2015-03-11 23:15:01 -06:00
type route struct {
2016-06-01 05:19:01 -06:00
reg * regexp . Regexp
2015-03-11 23:15:01 -06:00
method string
2016-06-01 05:19:01 -06:00
handler func ( serviceHandler )
2015-03-11 23:15:01 -06:00
}
2014-04-10 12:20:58 -06:00
var routes = [ ] route {
2019-06-12 13:41:28 -06:00
{ regexp . MustCompile ( ` (.*?)/git-upload-pack$ ` ) , "POST" , serviceUploadPack } ,
{ regexp . MustCompile ( ` (.*?)/git-receive-pack$ ` ) , "POST" , serviceReceivePack } ,
{ regexp . MustCompile ( ` (.*?)/info/refs$ ` ) , "GET" , getInfoRefs } ,
{ regexp . MustCompile ( ` (.*?)/HEAD$ ` ) , "GET" , getTextFile } ,
{ regexp . MustCompile ( ` (.*?)/objects/info/alternates$ ` ) , "GET" , getTextFile } ,
{ regexp . MustCompile ( ` (.*?)/objects/info/http-alternates$ ` ) , "GET" , getTextFile } ,
{ regexp . MustCompile ( ` (.*?)/objects/info/packs$ ` ) , "GET" , getInfoPacks } ,
{ regexp . MustCompile ( ` (.*?)/objects/info/[^/]*$ ` ) , "GET" , getTextFile } ,
{ regexp . MustCompile ( ` (.*?)/objects/[0-9a-f] { 2}/[0-9a-f] { 38}$ ` ) , "GET" , getLooseObject } ,
{ regexp . MustCompile ( ` (.*?)/objects/pack/pack-[0-9a-f] { 40}\.pack$ ` ) , "GET" , getPackFile } ,
{ regexp . MustCompile ( ` (.*?)/objects/pack/pack-[0-9a-f] { 40}\.idx$ ` ) , "GET" , getIdxFile } ,
2014-04-10 12:20:58 -06:00
}
2019-06-26 12:15:26 -06:00
func getGitConfig ( option , dir string ) string {
out , err := git . NewCommand ( "config" , option ) . RunInDir ( dir )
2016-06-01 05:19:01 -06:00
if err != nil {
2019-06-01 09:00:21 -06:00
log . Error ( "%v - %s" , err , out )
2015-11-30 18:45:55 -07:00
}
2017-02-25 07:54:40 -07:00
return out [ 0 : len ( out ) - 1 ]
2016-06-01 05:19:01 -06:00
}
2015-11-30 18:45:55 -07:00
2016-06-01 05:19:01 -06:00
func getConfigSetting ( service , dir string ) bool {
service = strings . Replace ( service , "-" , "" , - 1 )
setting := getGitConfig ( "http." + service , dir )
if service == " uploadpack " {
return setting != "false"
2015-11-30 18:45:55 -07:00
}
2016-06-01 05:19:01 -06:00
return setting == "true"
2015-11-30 18:45:55 -07:00
}
2016-06-01 05:19:01 -06:00
func hasAccess ( service string , h serviceHandler , checkContentType bool ) bool {
if checkContentType {
if h . r . Header . Get ( "Content-Type" ) != fmt . Sprintf ( "application/x-git-%s-request" , service ) {
return false
2014-04-10 12:20:58 -06:00
}
}
2016-06-01 05:19:01 -06:00
if ! ( service == "upload-pack" || service == "receive-pack" ) {
return false
}
if service == "receive-pack" {
return h . cfg . ReceivePack
}
if service == "upload-pack" {
return h . cfg . UploadPack
}
2014-04-10 12:20:58 -06:00
2016-06-01 05:19:01 -06:00
return getConfigSetting ( service , h . dir )
2014-04-10 12:20:58 -06:00
}
2016-06-01 05:19:01 -06:00
func serviceRPC ( h serviceHandler , service string ) {
2019-06-12 13:41:28 -06:00
defer func ( ) {
if err := h . r . Body . Close ( ) ; err != nil {
log . Error ( "serviceRPC: Close: %v" , err )
}
} ( )
2014-04-10 12:20:58 -06:00
2016-06-01 05:19:01 -06:00
if ! hasAccess ( service , h , true ) {
h . w . WriteHeader ( http . StatusUnauthorized )
2014-04-10 12:20:58 -06:00
return
}
2017-02-21 08:02:10 -07:00
2016-06-01 05:19:01 -06:00
h . w . Header ( ) . Set ( "Content-Type" , fmt . Sprintf ( "application/x-git-%s-result" , service ) )
2014-04-10 12:20:58 -06:00
2017-02-25 07:54:40 -07:00
var err error
var reqBody = h . r . Body
2014-10-15 14:28:38 -06:00
// Handle GZIP.
2016-06-01 05:19:01 -06:00
if h . r . Header . Get ( "Content-Encoding" ) == "gzip" {
2014-10-15 14:28:38 -06:00
reqBody , err = gzip . NewReader ( reqBody )
if err != nil {
2019-06-01 09:00:21 -06:00
log . Error ( "Fail to create gzip reader: %v" , err )
2016-06-01 05:19:01 -06:00
h . w . WriteHeader ( http . StatusInternalServerError )
2014-10-15 14:28:38 -06:00
return
}
}
2017-02-25 07:54:40 -07:00
// set this for allow pre-receive and post-receive execute
h . environ = append ( h . environ , "SSH_ORIGINAL_COMMAND=" + service )
2017-02-21 08:02:10 -07:00
2017-02-25 07:54:40 -07:00
var stderr bytes . Buffer
2019-06-26 12:15:26 -06:00
cmd := exec . Command ( git . GitExecutable , service , "--stateless-rpc" , h . dir )
2016-06-01 05:19:01 -06:00
cmd . Dir = h . dir
2017-02-25 07:54:40 -07:00
if service == "receive-pack" {
cmd . Env = append ( os . Environ ( ) , h . environ ... )
}
2016-06-01 05:19:01 -06:00
cmd . Stdout = h . w
2017-02-25 07:54:40 -07:00
cmd . Stdin = reqBody
cmd . Stderr = & stderr
2014-10-15 14:28:38 -06:00
if err := cmd . Run ( ) ; err != nil {
2019-06-01 09:00:21 -06:00
log . Error ( "Fail to serve RPC(%s): %v - %v" , service , err , stderr )
2014-04-10 12:20:58 -06:00
return
}
}
2016-06-01 05:19:01 -06:00
func serviceUploadPack ( h serviceHandler ) {
serviceRPC ( h , "upload-pack" )
2014-04-10 12:20:58 -06:00
}
2016-06-01 05:19:01 -06:00
func serviceReceivePack ( h serviceHandler ) {
serviceRPC ( h , "receive-pack" )
2014-04-10 12:20:58 -06:00
}
func getServiceType ( r * http . Request ) string {
serviceType := r . FormValue ( "service" )
2016-06-01 05:19:01 -06:00
if ! strings . HasPrefix ( serviceType , "git-" ) {
2014-04-10 12:20:58 -06:00
return ""
}
return strings . Replace ( serviceType , "git-" , "" , 1 )
}
2016-06-01 05:19:01 -06:00
func updateServerInfo ( dir string ) [ ] byte {
2019-06-26 12:15:26 -06:00
out , err := git . NewCommand ( "update-server-info" ) . RunInDirBytes ( dir )
if err != nil {
log . Error ( fmt . Sprintf ( "%v - %s" , err , string ( out ) ) )
}
return out
2014-04-10 12:20:58 -06:00
}
2016-06-01 05:19:01 -06:00
func packetWrite ( str string ) [ ] byte {
2017-02-25 07:54:40 -07:00
s := strconv . FormatInt ( int64 ( len ( str ) + 4 ) , 16 )
2016-06-01 05:19:01 -06:00
if len ( s ) % 4 != 0 {
s = strings . Repeat ( "0" , 4 - len ( s ) % 4 ) + s
2014-04-10 12:20:58 -06:00
}
2016-06-01 05:19:01 -06:00
return [ ] byte ( s + str )
2014-04-10 12:20:58 -06:00
}
2016-06-01 05:19:01 -06:00
func getInfoRefs ( h serviceHandler ) {
h . setHeaderNoCache ( )
if hasAccess ( getServiceType ( h . r ) , h , false ) {
service := getServiceType ( h . r )
2019-06-26 12:15:26 -06:00
refs , err := git . NewCommand ( service , "--stateless-rpc" , "--advertise-refs" , "." ) . RunInDirBytes ( h . dir )
if err != nil {
log . Error ( fmt . Sprintf ( "%v - %s" , err , string ( refs ) ) )
}
2016-06-01 05:19:01 -06:00
h . w . Header ( ) . Set ( "Content-Type" , fmt . Sprintf ( "application/x-git-%s-advertisement" , service ) )
h . w . WriteHeader ( http . StatusOK )
2019-06-12 13:41:28 -06:00
_ , _ = h . w . Write ( packetWrite ( "# service=git-" + service + "\n" ) )
_ , _ = h . w . Write ( [ ] byte ( "0000" ) )
_ , _ = h . w . Write ( refs )
2016-06-01 05:19:01 -06:00
} else {
updateServerInfo ( h . dir )
h . sendFile ( "text/plain; charset=utf-8" )
2014-04-10 12:20:58 -06:00
}
}
2016-06-01 05:19:01 -06:00
func getTextFile ( h serviceHandler ) {
h . setHeaderNoCache ( )
h . sendFile ( "text/plain" )
2014-04-10 12:20:58 -06:00
}
2016-06-01 05:19:01 -06:00
func getInfoPacks ( h serviceHandler ) {
h . setHeaderCacheForever ( )
h . sendFile ( "text/plain; charset=utf-8" )
2014-04-10 12:20:58 -06:00
}
2016-06-01 05:19:01 -06:00
func getLooseObject ( h serviceHandler ) {
h . setHeaderCacheForever ( )
h . sendFile ( "application/x-git-loose-object" )
2014-04-10 12:20:58 -06:00
}
2016-06-01 05:19:01 -06:00
func getPackFile ( h serviceHandler ) {
h . setHeaderCacheForever ( )
h . sendFile ( "application/x-git-packed-objects" )
}
2014-04-10 12:20:58 -06:00
2016-06-01 05:19:01 -06:00
func getIdxFile ( h serviceHandler ) {
h . setHeaderCacheForever ( )
h . sendFile ( "application/x-git-packed-objects-toc" )
2014-04-10 12:20:58 -06:00
}
2016-06-01 05:19:01 -06:00
func getGitRepoPath ( subdir string ) ( string , error ) {
if ! strings . HasSuffix ( subdir , ".git" ) {
subdir += ".git"
}
2014-04-10 12:20:58 -06:00
2016-06-01 05:19:01 -06:00
fpath := path . Join ( setting . RepoRootPath , subdir )
if _ , err := os . Stat ( fpath ) ; os . IsNotExist ( err ) {
return "" , err
2014-04-10 12:20:58 -06:00
}
2016-06-01 05:19:01 -06:00
return fpath , nil
2014-04-10 12:20:58 -06:00
}
2016-11-24 00:04:31 -07:00
// HTTPBackend middleware for git smart HTTP protocol
2016-06-01 05:19:01 -06:00
func HTTPBackend ( ctx * context . Context , cfg * serviceConfig ) http . HandlerFunc {
return func ( w http . ResponseWriter , r * http . Request ) {
for _ , route := range routes {
r . URL . Path = strings . ToLower ( r . URL . Path ) // blue: In case some repo name has upper case name
if m := route . reg . FindStringSubmatch ( r . URL . Path ) ; m != nil {
2016-10-04 10:58:14 -06:00
if setting . Repository . DisableHTTPGit {
2016-09-18 02:54:33 -06:00
w . WriteHeader ( http . StatusForbidden )
2019-06-12 13:41:28 -06:00
_ , err := w . Write ( [ ] byte ( "Interacting with repositories by HTTP protocol is not allowed" ) )
if err != nil {
log . Error ( err . Error ( ) )
}
2016-09-18 02:54:33 -06:00
return
}
2016-06-01 05:19:01 -06:00
if route . method != r . Method {
if r . Proto == "HTTP/1.1" {
w . WriteHeader ( http . StatusMethodNotAllowed )
2019-06-12 13:41:28 -06:00
_ , err := w . Write ( [ ] byte ( "Method Not Allowed" ) )
if err != nil {
log . Error ( err . Error ( ) )
}
2016-06-01 05:19:01 -06:00
} else {
w . WriteHeader ( http . StatusBadRequest )
2019-06-12 13:41:28 -06:00
_ , err := w . Write ( [ ] byte ( "Bad Request" ) )
if err != nil {
log . Error ( err . Error ( ) )
}
2016-06-01 05:19:01 -06:00
}
return
}
2014-04-10 12:20:58 -06:00
2016-06-01 05:19:01 -06:00
file := strings . Replace ( r . URL . Path , m [ 1 ] + "/" , "" , 1 )
dir , err := getGitRepoPath ( m [ 1 ] )
if err != nil {
2019-06-01 09:00:21 -06:00
log . Error ( err . Error ( ) )
2018-01-10 14:34:17 -07:00
ctx . NotFound ( "HTTPBackend" , err )
2016-06-01 05:19:01 -06:00
return
}
2014-04-10 12:20:58 -06:00
2017-02-25 07:54:40 -07:00
route . handler ( serviceHandler { cfg , w , r , dir , file , cfg . Env } )
2016-06-01 05:19:01 -06:00
return
}
}
2018-01-10 14:34:17 -07:00
ctx . NotFound ( "HTTPBackend" , nil )
2016-06-01 05:19:01 -06:00
}
2014-04-10 12:20:58 -06:00
}