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
138
139
140
141
142
143
144
145
|
package imap
import (
"fmt"
"net/url"
"strings"
imapClient "github.com/emersion/go-imap/client"
"github.com/Necoro/feed2imap-go/internal/log"
)
const (
imapsPort = "993"
imapPort = "143"
imapsSchema = "imaps"
imapSchema = "imap"
)
func forceTLS(url *url.URL) bool {
return url.Scheme == imapsSchema || url.Port() == imapsPort
}
func setDefaultScheme(url *url.URL) {
switch url.Scheme {
case imapSchema, imapsSchema:
return
default:
oldScheme := url.Scheme
if url.Port() == imapsPort {
url.Scheme = imapsSchema
} else {
url.Scheme = imapSchema
}
if oldScheme != "" {
log.Warnf("Unknown scheme '%s', defaulting to '%s'", oldScheme, url.Scheme)
}
}
}
func setDefaultPort(url *url.URL) {
if url.Port() == "" {
var port string
if url.Scheme == imapsSchema {
port = imapsPort
} else {
port = imapPort
}
url.Host += ":" + port
}
}
func sanitizeUrl(url *url.URL) {
setDefaultScheme(url)
setDefaultPort(url)
}
func newImapClient(url *url.URL, forceTls bool) (*imapClient.Client,error) {
if forceTls {
c, err := imapClient.DialTLS(url.Host, nil)
if err != nil {
return nil, fmt.Errorf("connecting (TLS) to %s: %w", url.Host, err)
}
log.Print("Connected to ", url.Host, " (TLS)")
return c, nil
} else {
c, err := imapClient.Dial(url.Host)
if err != nil {
return nil, fmt.Errorf("connecting to %s: %w", url.Host, err)
}
return c, nil
}
}
func (client *Client) connect(url *url.URL, forceTls bool) (*connection, error) {
c, err := newImapClient(url, forceTls)
if err != nil {
return nil, err
}
conn := client.createConnection(c)
if !forceTls {
if err = conn.startTls(); err != nil {
return nil, err
}
}
pwd, _ := url.User.Password()
if err = c.Login(url.User.Username(), pwd); err != nil {
return nil, fmt.Errorf("login to %s: %w", url.Host, err)
}
return conn, nil
}
func Connect(url *url.URL) (*Client, error) {
var err error
sanitizeUrl(url)
forceTls := forceTLS(url)
client := NewClient()
client.host = url.Host
defer func() {
if err != nil {
client.Disconnect()
}
}()
var conn *connection // the main connection
if conn, err = client.connect(url, forceTls); err != nil {
return nil, err
}
delim, err := conn.fetchDelimiter()
if err != nil {
return nil, fmt.Errorf("fetching delimiter: %w", err)
}
client.delimiter = delim
toplevel := url.Path
if toplevel[0] == '/' {
toplevel = toplevel[1:]
}
client.toplevel = client.folderName(strings.Split(toplevel, "/"))
log.Printf("Determined '%s' as toplevel, with '%s' as delimiter", client.toplevel, client.delimiter)
if err = conn.ensureFolder(client.toplevel); err != nil {
return nil, err
}
// the other connections
for i := 1; i < len(client.connections); i++ {
if _, err := client.connect(url, forceTls); err != nil { // explicitly new var 'err', b/c these are now harmless
log.Warnf("connecting #%d: %s", i, err)
}
}
client.startCommander()
return client, nil
}
|
