package server import ( "net/http" "strconv" "strings" "gitlab.com/Timfa/bluegit/internal/access" "gitlab.com/Timfa/bluegit/internal/desctpl" "gitlab.com/Timfa/bluegit/internal/gitrepo" "gitlab.com/Timfa/bluegit/internal/i18n" "gitlab.com/Timfa/bluegit/internal/store" ) func (s *Server) guard(w http.ResponseWriter, r *http.Request, min access.Role) (store.User, store.Repo, access.Role, bool) { owner := r.PathValue("owner") name := strings.TrimSuffix(r.PathValue("repo"), ".git") repo, err := s.Store.RepoByPath(r.Context(), owner, name) if err != nil { http.NotFound(w, r) return store.User{}, store.Repo{}, "", false } p := s.who(r) var role access.Role if p.OK { role, err = s.Store.EffectiveRole(r.Context(), p.User.ID, repo.ID) if err != nil { http.Error(w, s.tr(r, "err.rights"), http.StatusInternalServerError) return store.User{}, store.Repo{}, "", false } } if isCrawler(r) { p = principal{} role = access.RoleNone } readable := role.CanRead() || repo.Visibility == "public" if !readable && releaseOnly(repo, role) && (r.Method == http.MethodGet || r.Method == http.MethodHead) && isRepoRootPath(r.URL.Path, repo) { // Privé repo met publieke releases: alleen de Releases-pagina. http.Redirect(w, r, "/"+repo.FullPath()+"/-/releases", http.StatusSeeOther) return store.User{}, store.Repo{}, "", false } if !readable { if isCrawler(r) { s.writeLockedCard(w, r) } else if p.OK { http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden) } else { http.NotFound(w, r) } return store.User{}, store.Repo{}, "", false } if min != access.RoleReadonly && !role.AtLeast(min) { http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden) return store.User{}, store.Repo{}, "", false } return p.User, repo, role, true } func (s *Server) repoView(w http.ResponseWriter, r *http.Request, repo store.Repo, role access.Role, title string) View { v := s.view(w, r, title) v.Repo = &repo v.Role = role v.CanWrite = role.CanWriteCode() v.CanAdmin = role.CanManageSettings() v.Rev = safeRev(r.URL.Query().Get("rev"), repo.DefaultBranch) v.CloneHTTP = strings.TrimRight(s.Cfg.BaseURL, "/") + "/" + repo.FullPath() + ".git" v.CloneSSH = s.Cfg.CloneSSH(repo.FullPath()) v.ShowReleases = canSeeReleases(repo, role) if releaseOnly(repo, role) { card := releaseOnlyCard(repo) v.Repo = &card v.ReleaseOnly = true v.CloneHTTP, v.CloneSSH, v.Rev = "", "", "" return v } s.fillSideCounts(r, &v, repo, role) return v } func (s *Server) fillSideCounts(r *http.Request, v *View, repo store.Repo, role access.Role) { var viewerID int64 if v.User != nil { viewerID = v.User.ID } mrs, issues, err := s.Store.OpenSidebarCounts(r.Context(), repo.ID, viewerID, role.CanTriageIssue()) if err != nil { if s.Log != nil { s.Log.Error("zijbalk-telling", "repo", repo.FullPath(), "err", err) } return } v.OpenMRCount = mrs v.OpenIssueCount = issues } func (s *Server) repoHome(w http.ResponseWriter, r *http.Request) { _, repo, role, ok := s.guard(w, r, access.RoleReadonly) if !ok { return } v := s.repoView(w, r, repo, role, repo.Name) v.Wide = true s.fillOverview(r, &v, repo) uid := int64(0) if v.User != nil { uid = v.User.ID v.ForkTargets = s.forkTargets(r.Context(), *v.User) } v.Stars, v.Starred = s.starState(r.Context(), uid, repo.ID) v.Fork = s.forkInfo(r.Context(), uid, repo) v.Heat = s.heatmap(r.Context(), 0, []int64{repo.ID}, s.langOf(r)) s.render(w, "repo", v) } func (s *Server) treeRoot(w http.ResponseWriter, r *http.Request) { r.SetPathValue("path", "") s.tree(w, r) } func (s *Server) tree(w http.ResponseWriter, r *http.Request) { _, repo, role, ok := s.guard(w, r, access.RoleReadonly) if !ok { return } rel, err := cleanRel(r.PathValue("path")) if err != nil { http.NotFound(w, r) return } v := s.repoView(w, r, repo, role, rel) v.Wide = true dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) if _, err := gitrepo.Tree(r.Context(), s.Git, dir, v.Rev, rel); err != nil && rel != "" { http.NotFound(w, r) return } s.fillFiles(r, &v, repo, rel, false) s.render(w, "files", v) } func (s *Server) blob(w http.ResponseWriter, r *http.Request) { _, repo, role, ok := s.guard(w, r, access.RoleReadonly) if !ok { return } rel, err := cleanRel(r.PathValue("path")) if err != nil || rel == "" { http.NotFound(w, r) return } v := s.repoView(w, r, repo, role, rel) v.Wide = true dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) if _, _, err := gitrepo.Blob(r.Context(), s.Git, dir, v.Rev, rel, 1); err != nil { http.NotFound(w, r) return } s.fillFiles(r, &v, repo, rel, true) s.render(w, "files", v) } func (s *Server) commits(w http.ResponseWriter, r *http.Request) { _, repo, role, ok := s.guard(w, r, access.RoleReadonly) if !ok { return } v := s.repoView(w, r, repo, role, "title.commits") v.Page = "commits" v.Wide = true v.Query = clipQuery(r.URL.Query().Get("q")) dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) s.branchList(r, &v, repo) page := commitPageNum(r.URL.Query().Get("page")) list, more := s.commitWindow(r.Context(), dir, v.Rev, v.Query, (page-1)*commitPageSize, commitPageSize) lang := i18n.Parse(v.Lang) rows := s.presentCommits(r.Context(), repo.ID, list, lang) for i := range rows { s.attachHeadPipeline(r.Context(), repo, &rows[i], lang) } v.Commits = rows v.CommitDays = groupCommitDays(rows, lang) if page > 1 { v.CommitPrev = commitListURL(repo.FullPath(), v.Rev, v.Query, page-1) } if more { v.CommitNext = commitListURL(repo.FullPath(), v.Rev, v.Query, page+1) } s.render(w, "commits", v) } func (s *Server) commit(w http.ResponseWriter, r *http.Request) { _, repo, role, ok := s.guard(w, r, access.RoleReadonly) if !ok { return } sha := r.PathValue("sha") if !safeSHA(sha) { http.NotFound(w, r) return } dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) c, err := gitrepo.Show(r.Context(), s.Git, dir, sha) if err != nil { http.NotFound(w, r) return } v := s.repoView(w, r, repo, role, c.Subject) v.Page = "commit" v.Wide = true lang := i18n.Parse(v.Lang) rows := s.presentCommits(r.Context(), repo.ID, []gitrepo.Commit{c}, lang) s.attachHeadPipeline(r.Context(), repo, &rows[0], lang) v.Commit = &rows[0] parents, files, err := gitrepo.CommitPatch(r.Context(), s.Git, dir, c.SHA) if err != nil && s.Log != nil { s.Log.Warn("commitdiff", "sha", c.SHA, "err", err) } v.CommitDiff = presentCommitDiff(repo.FullPath(), c.SHA, parents, files) s.render(w, "commit", v) } func (s *Server) mergeRequests(w http.ResponseWriter, r *http.Request) { _, repo, role, ok := s.guard(w, r, access.RoleReadonly) if !ok { return } s.absorbMergedMRs(r.Context(), repo) v := s.repoView(w, r, repo, role, "title.mrs") v.Page = "mrs" v.Wide = true all, _ := s.Store.ListMergeRequests(r.Context(), repo.ID) v.Flow = s.flowMRs(r, repo, role, all) s.render(w, "mrs", v) } func (s *Server) createMR(w http.ResponseWriter, r *http.Request) { u, repo, _, ok := s.guard(w, r, access.RoleDeveloper) if !ok || !s.csrfOK(w, r) { return } source := safeRev(r.FormValue("source"), "") target := safeRev(r.FormValue("target"), repo.DefaultBranch) desc := desctpl.Expand(r.FormValue("description"), s.mrVars(r, repo, source, target)) mr, err := s.opCreateMR(r.Context(), u, repo, r.FormValue("title"), desc, source, target, r.FormValue("draft") == "1") if err == nil { err = s.Store.SetMergeOptions(r.Context(), mr.ID, r.FormValue("remove_source_branch") == "1", r.FormValue("squash") == "1", r.FormValue("squash_commit_message")) } if !s.uiOK(w, r, repoURL(repo)+"/-/merge-requests", err) { return } num := strconv.FormatInt(mr.Number, 10) s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+num, s.tr(r, "flash.mrOpened"), "") } func (s *Server) showMR(w http.ResponseWriter, r *http.Request) { u, repo, role, ok := s.guard(w, r, access.RoleReadonly) if !ok { return } s.absorbMergedMRs(r.Context(), repo) n, err := strconv.ParseInt(r.PathValue("number"), 10, 64) if err != nil { http.NotFound(w, r) return } mr, err := s.Store.MergeRequestByNumber(r.Context(), repo.ID, n) if err != nil { http.NotFound(w, r) return } v := s.repoView(w, r, repo, role, mr.Title) v.Page = "mr" v.MR = &mr v.Wide = true patterns, _ := s.Store.ProtectedPatterns(r.Context(), repo.ID) v.CanComment = role.AtLeast(access.RoleReadonly) v.CanMerge = mr.Status == "open" && role.CanMerge(access.BranchProtected(patterns, mr.TargetBranch)) v.CanApply = mr.Status == "open" && role.CanPushBranch(access.BranchProtected(patterns, mr.SourceBranch)) v.MergeBlocks = s.mergeBlocks(r, repo, mr) v.CanForce = v.CanMerge && role.CanManageSettings() && len(v.MergeBlocks) > 0 s.fillMRPipeline(r, &v, repo, mr) s.fillReviews(r, &v, repo, mr, role) if u.ID != 0 { mine := u.ID == mr.AuthorID || role.CanManageSettings() v.CanClose = mr.Status == "open" && mine v.CanReopen = mr.Status == "closed" && mine } s.finishMR(r, &v, repo, mr, u) s.render(w, "mr", v) } func (s *Server) createNote(w http.ResponseWriter, r *http.Request) { u, repo, _, ok := s.guard(w, r, access.RoleReadonly) if !ok || !s.csrfOK(w, r) { return } n, err := strconv.ParseInt(r.PathValue("number"), 10, 64) if err != nil { http.NotFound(w, r) return } back := repoURL(repo) + "/-/merge-requests/" + r.PathValue("number") parent, _ := strconv.ParseInt(r.FormValue("parent"), 10, 64) start, _ := strconv.Atoi(r.FormValue("line_start")) end, _ := strconv.Atoi(r.FormValue("line_end")) if _, err := s.opAddNote(r, u, repo, n, r.FormValue("body"), r.FormValue("path"), start, end, parent); !s.uiOK(w, r, back, err) { return } s.redirect(w, r, back, s.tr(r, "flash.note"), "") } func (s *Server) mergeMR(w http.ResponseWriter, r *http.Request) { u, repo, _, ok := s.guard(w, r, access.RoleDeveloper) if !ok || !s.csrfOK(w, r) { return } n, err := strconv.ParseInt(r.PathValue("number"), 10, 64) if err != nil { http.NotFound(w, r) return } back := repoURL(repo) + "/-/merge-requests/" + r.PathValue("number") out, err := s.opMergeMR(r, u, repo, n, formMergeChoice(r)) if !s.uiOK(w, r, back, err) { return } notice := s.tr(r, out.Notice) if out.Arg != "" { notice = s.tr(r, out.Notice, out.Arg) } s.redirect(w, r, back, notice, "") } func formMergeChoice(r *http.Request) mergeChoice { remove := r.FormValue("remove_source_branch") == "1" squash := r.FormValue("squash") == "1" message := r.FormValue("squash_commit_message") return mergeChoice{ FromForm: true, Remove: &remove, Squash: &squash, Message: &message, Force: r.FormValue("force") == "1", Confirm: r.FormValue("confirm_force") == "1", } } func (s *Server) closeMR(w http.ResponseWriter, r *http.Request) { u, repo, _, ok := s.guard(w, r, access.RoleReadonly) if !ok || !s.csrfOK(w, r) { return } n, err := strconv.ParseInt(r.PathValue("number"), 10, 64) if err != nil { http.NotFound(w, r) return } back := repoURL(repo) + "/-/merge-requests/" + r.PathValue("number") if !s.uiOK(w, r, back, s.opCloseMR(r.Context(), u, repo, n, false)) { return } s.redirect(w, r, back, s.tr(r, "flash.closed"), "") } func (s *Server) mrFromRequest(r *http.Request, repoID int64) (store.MergeRequest, error) { n, err := strconv.ParseInt(r.PathValue("number"), 10, 64) if err != nil { return store.MergeRequest{}, err } return s.Store.MergeRequestByNumber(r.Context(), repoID, n) } func (s *Server) pipelines(w http.ResponseWriter, r *http.Request) { _, repo, role, ok := s.guard(w, r, access.RoleReadonly) if !ok { return } if id := strings.TrimSpace(r.URL.Query().Get("show")); id != "" { if n, err := strconv.ParseInt(id, 10, 64); err == nil && n > 0 { http.Redirect(w, r, repoURL(repo)+"/-/pipelines/"+id, http.StatusSeeOther) return } } v := s.repoView(w, r, repo, role, "title.pipelines") v.Wide = true v.Page = "pipelines" s.fillPipelines(r, &v, repo) if wantsJSON(r) { s.writePipeList(w, v) return } s.render(w, "pipelines", v) } func (s *Server) pipeline(w http.ResponseWriter, r *http.Request) { _, repo, role, ok := s.guard(w, r, access.RoleReadonly) if !ok { return } id, err := strconv.ParseInt(r.PathValue("id"), 10, 64) if err != nil { http.NotFound(w, r) return } p, err := s.Store.PipelineByID(r.Context(), repo.ID, id) if err != nil { http.NotFound(w, r) return } v := s.repoView(w, r, repo, role, "title.pipeline") v.Wide = true v.Page = "pipelines" v.Pipe = &p jobs, _ := s.Store.JobsByPipeline(r.Context(), p.ID) v.Jobs = jobs ranks := s.queueRanks(r.Context()) tr := func(key string, args ...any) string { return s.tr(r, key, args...) } v.PipeStatus = displayStatus(s.pipeStatusFor(p), jobs) if blk, ok := s.protectedBlocker(p); ok { v.PipeWait = tr("pipe.waitingFor", strconv.Quote(blk.Name), blk.PipelineID) } if role.CanWriteCode() { v.PipeCancel = cancelView(tr, tr("pipe.cancelPipeline"), tr("pipe.cancelPipeAsk"), jobs) } v.PipeLabel = tr("pipe." + v.PipeStatus) v.PipeSource = s.pipelineSourceText(r, repo, p) v.PipeJobs = linksFor(jobs, ranks, tr) v.PipeStages = stageViews(jobs, ranks, tr) v.PipeFailed = jobsFailed(jobs) v.Live = jobsLive(p.Status, jobs) v.LiveURL = repoURL(repo) + "/-/pipelines/" + strconv.FormatInt(p.ID, 10) if wantsJSON(r) { s.writePipeDetail(w, v) return } s.render(w, "pipeline", v) } func (s *Server) runPipeline(w http.ResponseWriter, r *http.Request) { u, repo, _, ok := s.guard(w, r, access.RoleDeveloper) if !ok || !s.csrfOK(w, r) { return } if _, err := s.opRunPipeline(r.Context(), u, repo, r.FormValue("ref"), "web"); !s.uiOK(w, r, repoURL(repo)+"/-/pipelines", err) { return } s.redirect(w, r, repoURL(repo)+"/-/pipelines", s.tr(r, "flash.pipeline"), "") } func (s *Server) releases(w http.ResponseWriter, r *http.Request) { _, repo, role, ok := s.guardReleases(w, r) if !ok { return } v := s.repoView(w, r, repo, role, "title.releases") v.Page = "releases" v.Wide = true v.Releases, _ = s.Store.ListReleases(r.Context(), repo.ID) s.render(w, "releases", v) } func (s *Server) createRepo(w http.ResponseWriter, r *http.Request) { u, ok := s.loginRequired(w, r) if !ok || !s.csrfOK(w, r) { return } repo, err := s.opCreateRepo(r.Context(), u, r.FormValue("name"), r.FormValue("description"), r.FormValue("group"), r.FormValue("visibility"), false) if err != nil { if statusOf(err) == http.StatusForbidden { http.Error(w, s.trErr(r, err), http.StatusForbidden) return } s.failCreate(w, r, s.trErr(r, err)) return } s.finishCreate(w, r, repoURL(repo), s.tr(r, "flash.repoCreated")) } func (s *Server) createGroup(w http.ResponseWriter, r *http.Request) { u, ok := s.loginRequired(w, r) if !ok || !s.csrfOK(w, r) { return } g, err := s.opCreateGroup(r.Context(), u, r.FormValue("name"), r.FormValue("description"), r.FormValue("default_role")) if err != nil { s.failCreate(w, r, s.trErr(r, err)) return } s.finishCreate(w, r, "/groups/"+g.Path, s.tr(r, "flash.groupCreated")) } func toEntries(base string, in []gitrepo.Entry) []EntryRow { var out []EntryRow for _, e := range in { p := e.Name if base != "" { p = base + "/" + e.Name } out = append(out, EntryRow{Name: e.Name, Type: e.Type, Path: p}) } return out } func cleanRel(p string) (string, error) { p = strings.TrimPrefix(p, "/") if p == "" || p == "." { return "", nil } if strings.HasPrefix(p, "/") || strings.Contains(p, "\\") || strings.Contains(p, "..") { return "", errBadID } return p, nil } func safeRev(s, fallback string) string { if s == "" { return fallback } if strings.HasPrefix(s, "-") || strings.Contains(s, "..") || strings.ContainsAny(s, " \t\n~^:?*[\\") { return fallback } return s } func safeSHA(s string) bool { if len(s) < 7 || len(s) > 64 { return false } for _, c := range s { if (c < '0' || c > '9') && (c < 'a' || c > 'f') && (c < 'A' || c > 'F') { return false } } return true } // isRepoRootPath: /{owner}/{repo}, met of zonder slash, of /{owner}/{repo}/-. func isRepoRootPath(p string, repo store.Repo) bool { t := strings.Trim(p, "/") return t == repo.FullPath() || t == repo.FullPath()+"/-" } // repoRootAlias: /{owner}/{repo}/ en /{owner}/{repo}/- gaan naar de projectpagina // (of, release-only, naar Releases via guard). Geen toegang: 404 zoals niet-bestaand. func (s *Server) repoRootAlias(w http.ResponseWriter, r *http.Request) { _, repo, _, ok := s.guard(w, r, access.RoleReadonly) if !ok { return } http.Redirect(w, r, "/"+repo.FullPath(), http.StatusSeeOther) }