package server import ( "net/http" "strconv" "strings" "gitlab.com/Timfa/bluegit/internal/access" "gitlab.com/Timfa/bluegit/internal/gitrepo" "gitlab.com/Timfa/bluegit/internal/names" "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, "rechten", http.StatusInternalServerError) return store.User{}, store.Repo{}, "", false } } readable := role.CanRead() || repo.Visibility == "public" if !readable { if p.OK { http.Error(w, "geen toegang", http.StatusForbidden) } else { http.NotFound(w, r) } return store.User{}, store.Repo{}, "", false } if min != access.RoleReadonly && !role.AtLeast(min) { http.Error(w, "geen toegang", 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()) return v } 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) v.Heat = s.heatmap(r.Context(), 0, []int64{repo.ID}) 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, "Commits") v.Page = "commits" dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) list, _ := gitrepo.Log(r.Context(), s.Git, dir, v.Rev, 50) v.Commits = toCommits(list) 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) row := toCommits([]gitrepo.Commit{c})[0] v.Commit = &row s.render(w, "commit", v) } func (s *Server) branches(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, "Branches") v.Page = "branches" dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) names, _ := gitrepo.Branches(r.Context(), s.Git, dir) patterns, _ := s.Store.ProtectedPatterns(r.Context(), repo.ID) for _, name := range names { v.Branches = append(v.Branches, BranchRow{Name: name, Protected: access.BranchProtected(patterns, name)}) } s.render(w, "branches", v) } func (s *Server) mergeRequests(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, "Merge requests") v.Page = "mrs" v.MRs, _ = s.Store.ListMergeRequests(r.Context(), repo.ID) dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) names, _ := gitrepo.Branches(r.Context(), s.Git, dir) for _, name := range names { v.Branches = append(v.Branches, BranchRow{Name: name}) } s.render(w, "mrs", v) } func (s *Server) createMR(w http.ResponseWriter, r *http.Request) { u, repo, role, ok := s.guard(w, r, access.RoleDeveloper) if !ok || !s.csrfOK(w, r) { return } if !role.CanWriteCode() { http.Error(w, "geen toegang", http.StatusForbidden) return } source := safeRev(r.FormValue("source"), "") target := safeRev(r.FormValue("target"), repo.DefaultBranch) if source == "" || source == target { s.redirect(w, r, repoURL(repo)+"/-/merge-requests", "", "kies twee verschillende branches") return } mr, err := s.Store.CreateMergeRequest(r.Context(), repo.ID, u.ID, r.FormValue("title"), r.FormValue("description"), source, target) if err != nil { s.redirect(w, r, repoURL(repo)+"/-/merge-requests", "", err.Error()) return } s.Dispatch(repo.ID, pushEvent(repo, "merge_request", target, "", u.Username, "merge request !"+strconv.FormatInt(mr.Number, 10)+" geopend: "+mr.Title, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10))) s.recordContribution(u.ID, repo.ID, "merge_request", mrRef(mr.ID), mr.CreatedAt) s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), "Merge request geopend", "") } func (s *Server) showMR(w http.ResponseWriter, r *http.Request) { _, repo, role, ok := s.guard(w, r, access.RoleReadonly) if !ok { return } 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.MR = &mr patterns, _ := s.Store.ProtectedPatterns(r.Context(), repo.ID) v.CanMerge = mr.Status == "open" && role.CanMerge(access.BranchProtected(patterns, mr.TargetBranch)) dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) diff, err := gitrepo.DiffStat(r.Context(), s.Git, dir, mr.TargetBranch, mr.SourceBranch) if err == nil { v.Diff = diff } notes, _ := s.Store.ListNotes(r.Context(), mr.ID) for _, n := range notes { v.Notes = append(v.Notes, NoteRow{Author: n.Author, Body: n.Body, When: dutchDate(n.CreatedAt)}) } 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 } if u.ID == 0 { http.Error(w, "geen toegang", http.StatusForbidden) return } mr, err := s.mrFromRequest(r, repo.ID) if err != nil { http.NotFound(w, r) return } back := repoURL(repo) + "/-/merge-requests/" + strconv.FormatInt(mr.Number, 10) if _, err := s.Store.AddNote(r.Context(), repo.ID, mr.ID, u.ID, r.FormValue("body")); err != nil { s.redirect(w, r, back, "", err.Error()) return } s.redirect(w, r, back, "Reactie geplaatst", "") } func (s *Server) mergeMR(w http.ResponseWriter, r *http.Request) { u, repo, role, ok := s.guard(w, r, access.RoleDeveloper) if !ok || !s.csrfOK(w, r) { return } mr, err := s.mrFromRequest(r, repo.ID) if err != nil || mr.Status != "open" { http.NotFound(w, r) return } patterns, _ := s.Store.ProtectedPatterns(r.Context(), repo.ID) if !role.CanMerge(access.BranchProtected(patterns, mr.TargetBranch)) { http.Error(w, "geen toegang tot de doelbranch", http.StatusForbidden) return } dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) before, _ := gitrepo.Refs(r.Context(), s.Git, dir) work := s.StoragePath() + "/tmp/merge-" + strconv.FormatInt(mr.ID, 10) email := u.Username + "@users.git.timfalken.com" msg := "Merge branch '" + mr.SourceBranch + "' into '" + mr.TargetBranch + "'" if err := gitrepo.Merge(r.Context(), s.Git, dir, work, mr.SourceBranch, mr.TargetBranch, u.Username, email, msg, role, patterns); err != nil { s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), "", err.Error()) return } _ = s.Store.SetMergeRequestStatus(r.Context(), mr.ID, "merged") after, _ := gitrepo.Refs(r.Context(), s.Git, dir) s.AfterPush(repo, u, before, after) s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), "Samengevoegd", "") } func (s *Server) closeMR(w http.ResponseWriter, r *http.Request) { u, repo, role, ok := s.guard(w, r, access.RoleDeveloper) if !ok || !s.csrfOK(w, r) { return } mr, err := s.mrFromRequest(r, repo.ID) if err != nil { http.NotFound(w, r) return } if mr.AuthorID != u.ID && !role.CanManageSettings() { http.Error(w, "geen toegang", http.StatusForbidden) return } _ = s.Store.SetMergeRequestStatus(r.Context(), mr.ID, "closed") s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), "Gesloten", "") } 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 } v := s.repoView(w, r, repo, role, "Pipelines") v.Pipes, _ = s.Store.ListPipelines(r.Context(), repo.ID) 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, "Pipeline") v.Pipe = &p v.Jobs, _ = s.Store.JobsByPipeline(r.Context(), p.ID) 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 } ref := safeRev(r.FormValue("ref"), repo.DefaultBranch) dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) shaOut, err := gitSHA(r, s.Git, dir, ref) if err != nil { s.redirect(w, r, repoURL(repo)+"/-/pipelines", "", "branch niet gevonden") return } s.startPipeline(r.Context(), repo, shaOut, "refs/heads/"+ref, u.Username) s.redirect(w, r, repoURL(repo)+"/-/pipelines", "Pipeline gestart", "") } func (s *Server) releases(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, "Releases") 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 } if s.StoragePath() == "" { s.redirect(w, r, "/", "", strings.TrimSpace(noStorageMsg)) return } name, err := names.Slug("repo", r.FormValue("name")) if err != nil { s.redirect(w, r, "/new", "", "Deze naam kan niet.") return } ownerKind := "user" ownerID := u.ID if gpath := strings.TrimSpace(r.FormValue("group")); gpath != "" { g, err := s.Store.GroupByPath(r.Context(), gpath) if err != nil { s.redirect(w, r, "/new", "", "groep niet gevonden") return } role, err := s.Store.GroupRole(r.Context(), g.ID, u.ID) if err != nil || !role.CanManageSettings() { http.Error(w, "geen toegang", http.StatusForbidden) return } ownerKind, ownerID = "group", g.ID } vis := r.FormValue("visibility") if vis != "public" { vis = "private" } repo, err := s.Store.CreateRepo(r.Context(), ownerKind, ownerID, name, r.FormValue("description"), s.Cfg.Git.DefaultBranch, vis) if err != nil { s.redirect(w, r, "/new", "", err.Error()) return } dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) if err := gitrepo.Init(s.Git, dir, repo.DefaultBranch, s.HookBin); err != nil { _ = s.Store.DeleteRepo(r.Context(), repo.ID) s.redirect(w, r, "/new", "", "git init: "+err.Error()) return } s.redirect(w, r, repoURL(repo), "Repository aangemaakt", "") } func (s *Server) createGroup(w http.ResponseWriter, r *http.Request) { u, ok := s.loginRequired(w, r) if !ok || !s.csrfOK(w, r) { return } display := strings.TrimSpace(r.FormValue("name")) path, err := names.Slug("group", display) if err != nil { s.redirect(w, r, "/new", "", "Deze naam kan niet.") return } g, err := s.Store.CreateGroup(r.Context(), u.ID, display, path, r.FormValue("description")) if err != nil { s.redirect(w, r, "/new", "", err.Error()) return } s.redirect(w, r, "/groups/"+g.Path, "Groep aangemaakt", "") } func toCommits(in []gitrepo.Commit) []CommitRow { var out []CommitRow for _, c := range in { out = append(out, CommitRow{SHA: c.SHA, Short: c.Short, Author: c.Author, Date: c.Date, Subject: c.Subject, Body: c.Body}) } return out } 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 }