update deps

vendor/github.com/archdx/zerolog-sentry/writer.go

@@ -418,9 +418,10 @@ func NewWithHub(hub *sentry.Hub, opts ...WriterOption) (*Writer, error) {
 	}
 
 	return &Writer{
-		hub:          hub,
-		levels:       levels,
-		flushTimeout: cfg.flushTimeout,
+		hub:             hub,
+		levels:          levels,
+		flushTimeout:    cfg.flushTimeout,
+		withBreadcrumbs: cfg.breadcrumbs,
 	}, nil
 }
 

vendor/github.com/emersion/go-smtp/.build.yml

@@ -1,4 +1,4 @@
-image: alpine/edge
+image: alpine/latest
 packages:
   - go
 sources:
@@ -8,10 +8,13 @@ artifacts:
 tasks:
   - build: |
       cd go-smtp
-      go build -v ./...
+      go build -race -v ./...
   - test: |
       cd go-smtp
-      go test -coverprofile=coverage.txt -covermode=atomic ./...
+      go test -race -coverprofile=coverage.txt -covermode=atomic ./...
   - coverage: |
       cd go-smtp
       go tool cover -html=coverage.txt -o ~/coverage.html
+  - gofmt: |
+      cd go-smtp
+      test -z $(gofmt -l .)

vendor/github.com/emersion/go-smtp/client.go

@@ -183,12 +183,9 @@ func (c *Client) greet() error {
 	c.conn.SetDeadline(time.Now().Add(c.CommandTimeout))
 	defer c.conn.SetDeadline(time.Time{})
 
-	_, _, err := c.text.ReadResponse(220)
+	_, _, err := c.readResponse(220)
 	if err != nil {
 		c.text.Close()
-		if protoErr, ok := err.(*textproto.Error); ok {
-			return toSMTPErr(protoErr)
-		}
 		return err
 	}
 
@@ -197,12 +194,23 @@ func (c *Client) greet() error {
 
 // hello runs a hello exchange if needed.
 func (c *Client) hello() error {
-	if !c.didHello {
-		c.didHello = true
-		if err := c.greet(); err != nil {
-			c.helloError = err
-		} else if err := c.ehlo(); err != nil {
+	if c.didHello {
+		return c.helloError
+	}
+
+	c.didHello = true
+	if err := c.greet(); err != nil {
+		c.helloError = err
+		return c.helloError
+	}
+
+	if err := c.ehlo(); err != nil {
+		var smtpError *SMTPError
+		if errors.As(err, &smtpError) && (smtpError.Code == 500 || smtpError.Code == 502) {
+			// The server doesn't support EHLO, fallback to HELO
 			c.helloError = c.helo()
+		} else {
+			c.helloError = err
 		}
 	}
 	return c.helloError
@@ -226,6 +234,14 @@ func (c *Client) Hello(localName string) error {
 	return c.hello()
 }
 
+func (c *Client) readResponse(expectCode int) (int, string, error) {
+	code, msg, err := c.text.ReadResponse(expectCode)
+	if protoErr, ok := err.(*textproto.Error); ok {
+		err = toSMTPErr(protoErr)
+	}
+	return code, msg, err
+}
+
 // cmd is a convenience function that sends a command and returns the response
 // textproto.Error returned by c.text.ReadResponse is converted into SMTPError.
 func (c *Client) cmd(expectCode int, format string, args ...interface{}) (int, string, error) {
@@ -238,15 +254,8 @@ func (c *Client) cmd(expectCode int, format string, args ...interface{}) (int, s
 	}
 	c.text.StartResponse(id)
 	defer c.text.EndResponse(id)
-	code, msg, err := c.text.ReadResponse(expectCode)
-	if err != nil {
-		if protoErr, ok := err.(*textproto.Error); ok {
-			smtpErr := toSMTPErr(protoErr)
-			return code, smtpErr.Message, smtpErr
-		}
-		return code, msg, err
-	}
-	return code, msg, nil
+
+	return c.readResponse(expectCode)
 }
 
 // helo sends the HELO greeting to the server. It should be used only when the
@@ -544,10 +553,10 @@ func (d *dataCloser) Close() error {
 	if d.c.lmtp {
 		for expectedResponses > 0 {
 			rcpt := d.c.rcpts[len(d.c.rcpts)-expectedResponses]
-			if _, _, err := d.c.text.ReadResponse(250); err != nil {
-				if protoErr, ok := err.(*textproto.Error); ok {
+			if _, _, err := d.c.readResponse(250); err != nil {
+				if smtpErr, ok := err.(*SMTPError); ok {
 					if d.statusCb != nil {
-						d.statusCb(rcpt, toSMTPErr(protoErr))
+						d.statusCb(rcpt, smtpErr)
 					}
 				} else {
 					return err
@@ -558,11 +567,8 @@ func (d *dataCloser) Close() error {
 			expectedResponses--
 		}
 	} else {
-		_, _, err := d.c.text.ReadResponse(250)
+		_, _, err := d.c.readResponse(250)
 		if err != nil {
-			if protoErr, ok := err.(*textproto.Error); ok {
-				return toSMTPErr(protoErr)
-			}
 			return err
 		}
 	}

vendor/github.com/emersion/go-smtp/conn.go

@@ -773,15 +773,11 @@ func (c *Conn) handleAuth(arg string) {
 	// Parse client initial response if there is one
 	var ir []byte
 	if len(parts) > 1 {
-		if parts[1] == "=" {
-			ir = []byte{}
-		} else {
-			var err error
-			ir, err = base64.StdEncoding.DecodeString(parts[1])
-			if err != nil {
-				c.writeResponse(454, EnhancedCode{4, 7, 0}, "Invalid base64 data")
-				return
-			}
+		var err error
+		ir, err = decodeSASLResponse(parts[1])
+		if err != nil {
+			c.writeResponse(454, EnhancedCode{4, 7, 0}, "Invalid base64 data")
+			return
 		}
 	}
 
@@ -820,14 +816,10 @@ func (c *Conn) handleAuth(arg string) {
 			return
 		}
 
-		if encoded == "=" {
-			response = []byte{}
-		} else {
-			response, err = base64.StdEncoding.DecodeString(encoded)
-			if err != nil {
-				c.writeResponse(454, EnhancedCode{4, 7, 0}, "Invalid base64 data")
-				return
-			}
+		response, err = decodeSASLResponse(encoded)
+		if err != nil {
+			c.writeResponse(454, EnhancedCode{4, 7, 0}, "Invalid base64 data")
+			return
 		}
 	}
 
@@ -835,6 +827,13 @@ func (c *Conn) handleAuth(arg string) {
 	c.didAuth = true
 }
 
+func decodeSASLResponse(s string) ([]byte, error) {
+	if s == "=" {
+		return []byte{}, nil
+	}
+	return base64.StdEncoding.DecodeString(s)
+}
+
 func (c *Conn) authMechanisms() []string {
 	if authSession, ok := c.Session().(AuthSession); ok {
 		return authSession.AuthMechanisms()

vendor/github.com/emersion/go-smtp/server.go

@@ -120,7 +120,7 @@ func (s *Server) Serve(l net.Listener) error {
 
 			err := s.handleConn(newConn(c, s))
 			if err != nil {
-				s.ErrorLog.Printf("handler error: %s", err)
+				s.ErrorLog.Printf("error handling %v: %s", c.RemoteAddr(), err)
 			}
 		}()
 	}