Add warning to set SENDMAIL_ARGS to -- (#19102) - gitea.git - Git with a cup of tea! Painless self-hosted all-in-one software development service, including Git hosting, code review, team collaboration, package registry and CI/CD: https://github.com/go-gitea/gitea

diff options

author	zeripath <art27@cantab.net>	2022-03-18 14:19:02 +0000
committer	GitHub <noreply@github.com>	2022-03-18 15:19:02 +0100
commit	fda5b9fc3e6dd831987979f37fe39f08963b875d (patch)
tree	49fa8108d0a7e36a804c05649814fbb286841bbb /docs
parent	7fc5fd6415f92120811747681bcde9ed42825151 (diff)
download	gitea-fda5b9fc3e6dd831987979f37fe39f08963b875d.tar.gz gitea-fda5b9fc3e6dd831987979f37fe39f08963b875d.zip

Add warning to set SENDMAIL_ARGS to -- (#19102)

Even with #17688 email addresses that contain an initial `-` may still be present in the db and it may in future still be possible to imagine a situation whereby initial `-` are repermitted. This PR simply updates the documentation to warn users to set their SENDMAIL_ARGS with a terminal `--` to prevent this possibility email addresses being interpreted as options. Signed-off-by: Andrew Thornton <art27@cantab.net>

Diffstat (limited to 'docs')

-rw-r--r--

docs/content/doc/advanced/config-cheat-sheet.en-us.md

-rw-r--r--

docs/content/doc/usage/email-setup.en-us.md

2 files changed, 2 insertions, 1 deletions

// Copyright 2014 The Gogs Authors. All rights reserved. // Use of this source code is governed by a MIT-style // license that can be found in the LICENSE file. package models import ( "crypto/tls" "encoding/json" "fmt" "io/ioutil" "strings" "time" "github.com/go-xorm/xorm" gouuid "github.com/satori/go.uuid" api "code.gitea.io/sdk/gitea" "code.gitea.io/gitea/modules/httplib" "code.gitea.io/gitea/modules/log" "code.gitea.io/gitea/modules/setting" "code.gitea.io/gitea/modules/sync" ) // HookQueue is a global queue of web hooks var HookQueue = sync.NewUniqueQueue(setting.Webhook.QueueLength) // HookContentType is the content type of a web hook type HookContentType int const ( // ContentTypeJSON is a JSON payload for web hooks ContentTypeJSON HookContentType = iota + 1 // ContentTypeForm is an url-encoded form payload for web hook ContentTypeForm ) var hookContentTypes = map[string]HookContentType{ "json": ContentTypeJSON, "form": ContentTypeForm, } // ToHookContentType returns HookContentType by given name. func ToHookContentType(name string) HookContentType { return hookContentTypes[name] } // Name returns the name of a given web hook's content type func (t HookContentType) Name() string { switch t { case ContentTypeJSON: return "json" case ContentTypeForm: return "form" } return "" } // IsValidHookContentType returns true if given name is a valid hook content type. func IsValidHookContentType(name string) bool { _, ok := hookContentTypes[name] return ok } // HookEvents is a set of web hook events type HookEvents struct { Create bool `json:"create"` Push bool `json:"push"` PullRequest bool `json:"pull_request"` } // HookEvent represents events that will delivery hook. type HookEvent struct { PushOnly bool `json:"push_only"` SendEverything bool `json:"send_everything"` ChooseEvents bool `json:"choose_events"` HookEvents `json:"events"` } // HookStatus is the status of a web hook type HookStatus int // Possible statuses of a web hook const ( HookStatusNone = iota HookStatusSucceed HookStatusFail ) // Webhook represents a web hook object. type Webhook struct { ID int64 `xorm:"pk autoincr"` RepoID int64 `xorm:"INDEX"` OrgID int64 `xorm:"INDEX"` URL string `xorm:"url TEXT"` ContentType HookContentType Secret string `xorm:"TEXT"` Events string `xorm:"TEXT"` *HookEvent `xorm:"-"` IsSSL bool `xorm:"is_ssl"` IsActive bool `xorm:"INDEX"` HookTaskType HookTaskType Meta string `xorm:"TEXT"` // store hook-specific attributes LastStatus HookStatus // Last delivery status Created time.Time `xorm:"-"` CreatedUnix int64 `xorm:"INDEX"` Updated time.Time `xorm:"-"` UpdatedUnix int64 `xorm:"INDEX"` } // BeforeInsert will be invoked by XORM before inserting a record // representing this object func (w *Webhook) BeforeInsert() { w.CreatedUnix = time.Now().Unix() w.UpdatedUnix = w.CreatedUnix } // BeforeUpdate will be invoked by XORM before updating a record // representing this object func (w *Webhook) BeforeUpdate() { w.UpdatedUnix = time.Now().Unix() } // AfterSet updates the webhook object upon setting a column func (w *Webhook) AfterSet(colName string, _ xorm.Cell) { var err error switch colName { case "events": w.HookEvent = &HookEvent{} if err = json.Unmarshal([]byte(w.Events), w.HookEvent); err != nil { log.Error(3, "Unmarshal[%d]: %v", w.ID, err) } case "created_unix": w.Created = time.Unix(w.CreatedUnix, 0).Local() case "updated_unix": w.Updated = time.Unix(w.UpdatedUnix, 0).Local() } } // GetSlackHook returns slack metadata func (w *Webhook) GetSlackHook() *SlackMeta { s := &SlackMeta{} if err := json.Unmarshal([]byte(w.Meta), s); err != nil { log.Error(4, "webhook.GetSlackHook(%d): %v", w.ID, err) } return s } // History returns history of webhook by given conditions. func (w *Webhook) History(page int) ([]*HookTask, error) { return HookTasks(w.ID, page) } // UpdateEvent handles conversion from HookEvent to Events. func (w *Webhook) UpdateEvent() error { data, err := json.Marshal(w.HookEvent) w.Events = string(data) return err } // HasCreateEvent returns true if hook enabled create event. func (w *Webhook) HasCreateEvent() bool { return w.SendEverything || (w.ChooseEvents && w.HookEvents.Create) } // HasPushEvent returns true if hook enabled push event. func (w *Webhook) HasPushEvent() bool { return w.PushOnly || w.SendEverything || (w.ChooseEvents && w.HookEvents.Push) } // HasPullRequestEvent returns true if hook enabled pull request event. func (w *Webhook) HasPullRequestEvent() bool { return w.SendEverything || (w.ChooseEvents && w.HookEvents.PullRequest) } // EventsArray returns an array of hook events func (w *Webhook) EventsArray() []string { events := make([]string, 0, 3) if w.HasCreateEvent() { events = append(events, "create") } if w.HasPushEvent() { events = append(events, "push") } if w.HasPullRequestEvent() { events = append(events, "pull_request") } return events } // CreateWebhook creates a new web hook. func CreateWebhook(w *Webhook) error { _, err := x.Insert(w) return err } // getWebhook uses argument bean as query condition, // ID must be specified and do not assign unnecessary fields. func getWebhook(bean *Webhook) (*Webhook, error) { has, err := x.Get(bean) if err != nil { return nil, err } else if !has { return nil, ErrWebhookNotExist{bean.ID} } return bean, nil } // GetWebhookByRepoID returns webhook of repository by given ID. func GetWebhookByRepoID(repoID, id int64) (*Webhook, error) { return getWebhook(&Webhook{ ID: id, RepoID: repoID, }) } // GetWebhookByOrgID returns webhook of organization by given ID. func GetWebhookByOrgID(orgID, id int64) (*Webhook, error) { return getWebhook(&Webhook{ ID: id, OrgID: orgID, }) } // GetActiveWebhooksByRepoID returns all active webhooks of repository. func GetActiveWebhooksByRepoID(repoID int64) ([]*Webhook, error) { webhooks := make([]*Webhook, 0, 5) return webhooks, x.Where("is_active=?", true). Find(&webhooks, &Webhook{RepoID: repoID}) } // GetWebhooksByRepoID returns all webhooks of a repository. func GetWebhooksByRepoID(repoID int64) ([]*Webhook, error) { webhooks := make([]*Webhook, 0, 5) return webhooks, x.Find(&webhooks, &Webhook{RepoID: repoID}) } // GetActiveWebhooksByOrgID returns all active webhooks for an organization. func GetActiveWebhooksByOrgID(orgID int64) (ws []*Webhook, err error) { err = x. Where("org_id=?", orgID). And("is_active=?", true). Find(&ws) return ws, err } // GetWebhooksByOrgID returns all webhooks for an organization. func GetWebhooksByOrgID(orgID int64) (ws []*Webhook, err error) { err = x.Find(&ws, &Webhook{OrgID: orgID}) return ws, err } // UpdateWebhook updates information of webhook. func UpdateWebhook(w *Webhook) error { _, err := x.Id(w.ID).AllCols().Update(w) return err } // deleteWebhook uses argument bean as query condition, // ID must be specified and do not assign unnecessary fields. func deleteWebhook(bean *Webhook) (err error) { sess := x.NewSession() defer sessionRelease(sess) if err = sess.Begin(); err != nil { return err } if count, err := sess.Delete(bean); err != nil { return err } else if count == 0 { return ErrWebhookNotExist{ID: bean.ID} } else if _, err = sess.Delete(&HookTask{HookID: bean.ID}); err != nil { return err } return sess.Commit() } // DeleteWebhookByRepoID deletes webhook of repository by given ID. func DeleteWebhookByRepoID(repoID, id int64) error { return deleteWebhook(&Webhook{ ID: id, RepoID: repoID, }) } // DeleteWebhookByOrgID deletes webhook of organization by given ID. func DeleteWebhookByOrgID(orgID, id int64) error { return deleteWebhook(&Webhook{ ID: id, OrgID: orgID, }) } // ___ ___ __ ___________ __ // / | \ ____ ____ | | _\__ ___/____ _____| | __ // / ~ \/ _ \ / _ \| |/ / | | \__ \ / ___/ |/ / // \ Y ( <_> | <_> ) < | | / __ \_\___ \| < // \___|_ / \____/ \____/|__|_ \ |____| (____ /____ >__|_ \ // \/ \/ \/ \/ \/ // HookTaskType is the type of an hook task type HookTaskType int // Types of hook tasks const ( GOGS HookTaskType = iota + 1 SLACK ) var hookTaskTypes = map[string]HookTaskType{ "gogs": GOGS, "slack": SLACK, } // ToHookTaskType returns HookTaskType by given name. func ToHookTaskType(name string) HookTaskType { return hookTaskTypes[name] } // Name returns the name of an hook task type func (t HookTaskType) Name() string { switch t { case GOGS: return "gogs" case SLACK: return "slack" } return "" } // IsValidHookTaskType returns true if given name is a valid hook task type. func IsValidHookTaskType(name string) bool { _, ok := hookTaskTypes[name] return ok } // HookEventType is the type of an hook event type HookEventType string // Types of hook events const ( HookEventCreate HookEventType = "create" HookEventPush HookEventType = "push" HookEventPullRequest HookEventType = "pull_request" ) // HookRequest represents hook task request information. type HookRequest struct { Headers map[string]string `json:"headers"` } // HookResponse represents hook task response information. type HookResponse struct { Status int `json:"status"` Headers map[string]string `json:"headers"` Body string `json:"body"` } // HookTask represents a hook task. type HookTask struct { ID int64 `xorm:"pk autoincr"` RepoID int64 `xorm:"INDEX"` HookID int64 UUID string Type HookTaskType URL string `xorm:"TEXT"` api.Payloader `xorm:"-"` PayloadContent string `xorm:"TEXT"` ContentType HookContentType EventType HookEventType IsSSL bool IsDelivered bool Delivered int64 DeliveredString string `xorm:"-"` // History info. IsSucceed bool RequestContent string `xorm:"TEXT"` RequestInfo *HookRequest `xorm:"-"` ResponseContent string `xorm:"TEXT"` ResponseInfo *HookResponse `xorm:"-"` } // BeforeUpdate will be invoked by XORM before updating a record // representing this object func (t *HookTask) BeforeUpdate() { if t.RequestInfo != nil { t.RequestContent = t.simpleMarshalJSON(t.RequestInfo) } if t.ResponseInfo != nil { t.ResponseContent = t.simpleMarshalJSON(t.ResponseInfo) } } // AfterSet updates the webhook object upon setting a column func (t *HookTask) AfterSet(colName string, _ xorm.Cell) { var err error switch colName { case "delivered": t.DeliveredString = time.Unix(0, t.Delivered).Format("2006-01-02 15:04:05 MST") case "request_content": if len(t.RequestContent) == 0 { return } t.RequestInfo = &HookRequest{} if err = json.Unmarshal([]byte(t.RequestContent), t.RequestInfo); err != nil { log.Error(3, "Unmarshal[%d]: %v", t.ID, err) } case "response_content": if len(t.ResponseContent) == 0 { return } t.ResponseInfo = &HookResponse{} if err = json.Unmarshal([]byte(t.ResponseContent), t.ResponseInfo); err != nil { log.Error(3, "Unmarshal [%d]: %v", t.ID, err) } } } func (t *HookTask) simpleMarshalJSON(v interface{}) string { p, err := json.Marshal(v) if err != nil { log.Error(3, "Marshal [%d]: %v", t.ID, err) } return string(p) } // HookTasks returns a list of hook tasks by given conditions. func HookTasks(hookID int64, page int) ([]*HookTask, error) { tasks := make([]*HookTask, 0, setting.Webhook.PagingNum) return tasks, x. Limit(setting.Webhook.PagingNum, (page-1)*setting.Webhook.PagingNum). Where("hook_id=?", hookID). Desc("id"). Find(&tasks) } // CreateHookTask creates a new hook task, // it handles conversion from Payload to PayloadContent. func CreateHookTask(t *HookTask) error { data, err := t.Payloader.JSONPayload() if err != nil { return err } t.UUID = gouuid.NewV4().String() t.PayloadContent = string(data) _, err = x.Insert(t) return err } // UpdateHookTask updates information of hook task. func UpdateHookTask(t *HookTask) error { _, err := x.Id(t.ID).AllCols().Update(t) return err } // PrepareWebhooks adds new webhooks to task queue for given payload. func PrepareWebhooks(repo *Repository, event HookEventType, p api.Payloader) error { ws, err := GetActiveWebhooksByRepoID(repo.ID) if err != nil { return fmt.Errorf("GetActiveWebhooksByRepoID: %v", err) } // check if repo belongs to org and append additional webhooks if repo.MustOwner().IsOrganization() { // get hooks for org orgHooks, err := GetActiveWebhooksByOrgID(repo.OwnerID) if err != nil { return fmt.Errorf("GetActiveWebhooksByOrgID: %v", err) } ws = append(ws, orgHooks...) } if len(ws) == 0 { return nil } var payloader api.Payloader for _, w := range ws { switch event { case HookEventCreate: if !w.HasCreateEvent() { continue } case HookEventPush: if !w.HasPushEvent() { continue } case HookEventPullRequest: if !w.HasPullRequestEvent() { continue } } // Use separate objects so modifications won't be made on payload on non-Gogs type hooks. switch w.HookTaskType { case SLACK: payloader, err = GetSlackPayload(p, event, w.Meta) if err != nil { return fmt.Errorf("GetSlackPayload: %v", err) } default: p.SetSecret(w.Secret) payloader = p } if err = CreateHookTask(&HookTask{ RepoID: repo.ID, HookID: w.ID, Type: w.HookTaskType, URL: w.URL, Payloader: payloader, ContentType: w.ContentType, EventType: event, IsSSL: w.IsSSL, }); err != nil { return fmt.Errorf("CreateHookTask: %v", err) } } return nil } func (t *HookTask) deliver() { t.IsDelivered = true timeout := time.Duration(setting.Webhook.DeliverTimeout) * time.Second req := httplib.Post(t.URL).SetTimeout(timeout, timeout). Header("X-Gogs-Delivery", t.UUID). Header("X-Gogs-Event", string(t.EventType)). Header("X-GitHub-Delivery", t.UUID). Header("X-GitHub-Event", string(t.EventType)). SetTLSClientConfig(&tls.Config{InsecureSkipVerify: setting.Webhook.SkipTLSVerify}) switch t.ContentType { case ContentTypeJSON: req = req.Header("Content-Type", "application/json").Body(t.PayloadContent) case ContentTypeForm: req.Param("payload", t.PayloadContent) } // Record delivery information. t.RequestInfo = &HookRequest{ Headers: map[string]string{}, } for k, vals := range req.Headers() { t.RequestInfo.Headers[k] = strings.Join(vals, ",") } t.ResponseInfo = &HookResponse{ Headers: map[string]string{}, } defer func() { t.Delivered = time.Now().UnixNano() if t.IsSucceed { log.Trace("Hook delivered: %s", t.UUID) } else { log.Trace("Hook delivery failed: %s", t.UUID) } // Update webhook last delivery status. w, err := GetWebhookByRepoID(t.RepoID, t.HookID) if err != nil { log.Error(5, "GetWebhookByID: %v", err) return } if t.IsSucceed { w.LastStatus = HookStatusSucceed } else { w.LastStatus = HookStatusFail } if err = UpdateWebhook(w); err != nil { log.Error(5, "UpdateWebhook: %v", err) return } }() resp, err := req.Response() if err != nil { t.ResponseInfo.Body = fmt.Sprintf("Delivery: %v", err) return } defer resp.Body.Close() // Status code is 20x can be seen as succeed. t.IsSucceed = resp.StatusCode/100 == 2 t.ResponseInfo.Status = resp.StatusCode for k, vals := range resp.Header { t.ResponseInfo.Headers[k] = strings.Join(vals, ",") } p, err := ioutil.ReadAll(resp.Body) if err != nil { t.ResponseInfo.Body = fmt.Sprintf("read body: %s", err) return } t.ResponseInfo.Body = string(p) } // DeliverHooks checks and delivers undelivered hooks. // TODO: shoot more hooks at same time. func DeliverHooks() { tasks := make([]*HookTask, 0, 10) x. Where("is_delivered=?", false). Iterate(new(HookTask), func(idx int, bean interface{}) error { t := bean.(*HookTask) t.deliver() tasks = append(tasks, t) return nil }) // Update hook task status. for _, t := range tasks { if err := UpdateHookTask(t); err != nil { log.Error(4, "UpdateHookTask [%d]: %v", t.ID, err) } } // Start listening on new hook requests. for repoID := range HookQueue.Queue() { log.Trace("DeliverHooks [repo_id: %v]", repoID) HookQueue.Remove(repoID) tasks = make([]*HookTask, 0, 5) if err := x.Where("repo_id=? AND is_delivered=?", repoID, false).Find(&tasks); err != nil { log.Error(4, "Get repository [%s] hook tasks: %v", repoID, err) continue } for _, t := range tasks { t.deliver() if err := UpdateHookTask(t); err != nil { log.Error(4, "UpdateHookTask [%d]: %v", t.ID, err) continue } } } } // InitDeliverHooks starts the hooks delivery thread func InitDeliverHooks() { go DeliverHooks() }


context:
space:
mode: