~sircmpwn/aerc

ref: 29de3297a157c0ac109121152fe2b5737fc81d95 aerc/commands/compose/send-message.go -rw-r--r-- 2.7 KiB
29de3297Drew DeVault Implement sending emails /o/ 1 year, 9 months ago
                                                                                
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
package compose

import (
	"crypto/tls"
	"errors"
	"fmt"
	"net/mail"
	"net/url"
	"strings"

	"github.com/emersion/go-sasl"
	"github.com/emersion/go-smtp"

	"git.sr.ht/~sircmpwn/aerc2/widgets"
)

func init() {
	register("send-message", SendMessage)
}

func SendMessage(aerc *widgets.Aerc, args []string) error {
	if len(args) > 1 {
		return errors.New("Usage: send-message")
	}
	composer, _ := aerc.SelectedTab().(*widgets.Composer)
	config := composer.Config()

	if config.Outgoing == "" {
		return errors.New(
			"No outgoing mail transport configured for this account")
	}

	uri, err := url.Parse(config.Outgoing)
	if err != nil {
		return err
	}
	var (
		scheme string
		auth   string = "plain"
	)
	parts := strings.Split(uri.Scheme, "+")
	if len(parts) == 1 {
		scheme = parts[0]
	} else if len(parts) == 2 {
		scheme = parts[0]
		auth = parts[1]
	} else {
		return fmt.Errorf("Unknown transfer protocol %s", uri.Scheme)
	}

	header, rcpts, err := composer.Header()
	if err != nil {
		return err
	}

	if config.From == "" {
		return errors.New("No 'From' configured for this account")
	}
	from, err := mail.ParseAddress(config.From)
	if err != nil {
		return err
	}

	var (
		saslClient sasl.Client
		conn       *smtp.Client
	)
	switch auth {
	case "":
		fallthrough
	case "none":
		saslClient = nil
	case "plain":
		password, _ := uri.User.Password()
		saslClient = sasl.NewPlainClient("", uri.User.Username(), password)
	default:
		return fmt.Errorf("Unsupported auth mechanism %s", auth)
	}

	tlsConfig := &tls.Config{
		// TODO: ask user first
		InsecureSkipVerify: true,
	}
	switch scheme {
	case "smtp":
		host := uri.Host
		if !strings.ContainsRune(host, ':') {
			host = host + ":587" // Default to submission port
		}
		conn, err = smtp.Dial(host)
		if err != nil {
			return err
		}
		defer conn.Close()
		if sup, _ := conn.Extension("STARTTLS"); sup {
			// TODO: let user configure tls?
			if err = conn.StartTLS(tlsConfig); err != nil {
				return err
			}
		}
	case "smtps":
		host := uri.Host
		if !strings.ContainsRune(host, ':') {
			host = host + ":465" // Default to smtps port
		}
		conn, err = smtp.DialTLS(host, tlsConfig)
		if err != nil {
			return err
		}
		defer conn.Close()
	}

	// TODO: sendmail
	if saslClient != nil {
		if err = conn.Auth(saslClient); err != nil {
			return err
		}
	}
	// TODO: the user could conceivably want to use a different From and sender
	if err = conn.Mail(from.Address); err != nil {
		return err
	}
	for _, rcpt := range rcpts {
		if err = conn.Rcpt(rcpt); err != nil {
			return err
		}
	}
	wc, err := conn.Data()
	if err != nil {
		return err
	}
	defer wc.Close()
	composer.WriteMessage(header, wc)
	composer.Close()
	aerc.RemoveTab(composer)
	return nil
}