about summary refs log tree commit diff stats
path: root/themes/hacker
blob: 8639dbe6ec0b3caf2ac34db69e4b56d4e975c514 (plain) (blame)
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
[colours]
bkgnd=default
titlebar=green
titlebar.text=black
titlebar.brackets=black
titlebar.unencrypted=black
titlebar.encrypted=black
titlebar.untrusted=black
titlebar.trusted=black
titlebar.online=black
titlebar.offline=black
titlebar.away=black
titlebar.chat=black
titlebar.dnd=black
titlebar.xa=black
statusbar=green
statusbar.text=black
statusbar.time=black
statusbar.brackets=black
statusbar.active=black
statusbar.new=black
main.text=green
main.text.me=green
main.text.them=green
main.splash=bold_green
main.help.header=bold_green
main.time=bold_green
input.text=bold_green
subscribed=bold_green
unsubscribed=green
otr.started.trusted=green
otr.started.untrusted=green
otr.ended=green
otr.trusted=green
otr.untrusted=green
online=bold_green
away=green
chat=bold_green
dnd=green
xa=green
offline=green
incoming=bold_green
mention=bold_green
trigger=bold_green
typing=green
gone=green
error=bold_green
roominfo=green
roommention=bold_green
roommention.term=bold_green
roomtrigger=bold_green
roomtrigger.term=bold_green
me=green
them=bold_green
roster.header=bold_green
roster.chat=bold_green
roster.online=bold_green
roster.away=green
roster.xa=green
roster.dnd=green
roster.offline=green
roster.chat.active=bold_green
roster.online.active=bold_green
roster.away.active=green
roster.xa.active=green
roster.dnd.active=green
roster.offline.active=green
roster.chat.unread=bold_green
roster.online.unread=bold_green
roster.away.unread=green
roster.xa.unread=green
roster.dnd.unread=green
roster.offline.unread=green
roster.room=green
roster.room=bold_green
occupants.header=bold_green
receipt.sent=bold_black
.go?id=1710c9054898e820700d673e21e7c7a90a3f67b1'>1710c90 ^
6394e38 ^
1710c90 ^
b0eaf51 ^





5dfeff7 ^




1710c90 ^

b389647 ^
026e8a1 ^

90453b5 ^
b389647 ^

312a53e ^

6394e38 ^

6fed04b ^
6394e38 ^
026e8a1 ^


90453b5 ^
6fed04b ^
6394e38 ^

1710c90 ^
e41ed82 ^
026e8a1 ^





30c0a9f ^

a0be5e8 ^
d603bbe ^
1710c90 ^
d603bbe ^
1710c90 ^


6394e38 ^
1710c90 ^






b0eaf51 ^



550ef0b ^

b0eaf51 ^
550ef0b ^



b0eaf51 ^
550ef0b ^
b0eaf51 ^

1710c90 ^

2dc4365 ^
6394e38 ^
1710c90 ^
1710c90 ^
626f91c ^
5dfeff7 ^







































d603bbe ^
6ddfc23 ^
e41ed82 ^

cc432ee ^

1710c90 ^



dc2a2c2 ^
d603bbe ^
e41ed82 ^
6ddfc23 ^
e41ed82 ^




e41ed82 ^
d603bbe ^
cc03f6f ^
2750f99 ^

b389647 ^

dc2a2c2 ^

acfe7d7 ^

fe1cabb ^

de36484 ^

27b2517 ^

95875b1 ^

312a53e ^

0535f63 ^

b1eb7ad ^

db213fd ^

b0bf09b ^

198661b ^

1710c90 ^
30c0a9f ^
6394e38 ^
026e8a1 ^
e41ed82 ^
026e8a1 ^

4cf0ea2 ^
026e8a1 ^

30c0a9f ^
6394e38 ^

2750f99 ^




b389647 ^
90453b5 ^
b389647 ^
2750f99 ^
cce7cb4 ^








2750f99 ^
05f00f0 ^





cce7cb4 ^
c610c3c ^

6ff3c7a ^
cce7cb4 ^


05f00f0 ^
3ace4ef ^






2750f99 ^


cc432ee ^

33aaf94 ^

cc432ee ^
33aaf94 ^










5dfeff7 ^













33aaf94 ^


cc432ee ^

33aaf94 ^
cc432ee ^


cc432ee ^
33aaf94 ^
cc432ee ^



33aaf94 ^

cc432ee ^





33aaf94 ^
cc432ee ^



























5dfeff7 ^







































6394e38 ^
6394e38 ^

d24e471 ^

1710c90 ^
d603bbe ^
1710c90 ^
d24e471 ^
1710c90 ^
d603bbe ^
1710c90 ^

d24e471 ^
1710c90 ^

2750f99 ^
6394e38 ^


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
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405


            
                    
             
             
                 
                 
                 

                 
 
                                     
                                                           
                                            
                             
 



                                                

 




                                                              



                                                      

                                       

 
                        
                       





                                           




                                                

         
                            

                              
                                    

                                   

                                                                   

 
                                                                 
                           


                                                       
                                                
              

 
                                                                   
                                                                      





                                                                           

                                                                               
                                  
                                
                        
                              


                                                      
                 






                                                                                          



                                                                                             

                                                  
                                                          



                                                                                  
                         
                                                            

                 

                                                              
                                                              
                 
 
                                      
                                                     







































                                                                                          
                            
                                                                              

                                                              

                                     



                                     
                                                                                                     
                                                                            
                               
                                                                              




                                                          
                                                                            
                                    
                                            

                                          

                                                   

                                              

                                            

                                            

                                                

                                                 

                                              

                                           

                                         

                                             

                                         

                                          

                                            
                
                                       
         
 
                                                                      

                                                
                                                                                          

                   
                     

 




                                                             
                                                   
                                           
                 
                                                          








                                                             
                       





                                                        
                                                  

                                                                                         
                                                                             


                                                                
                       






                                                                  


         

                                                        

                                   
         










                                                             













                                                                  


                                                            

                                
                                         


                                       
                                       
                                                                    



                                               

                                                      





                                                                                 
 



























                                                                          







































                                                                               
                            

                        

                                                         
                                                                               
                                                                        
                                                                      
                                       
                                              
                                                                  

                                                                      
                                       

                                           
                                                  


                 
package imap

import (
	"crypto/tls"
	"fmt"
	"net"
	"net/url"
	"strconv"
	"strings"
	"syscall"
	"time"

	"github.com/emersion/go-imap"
	sortthread "github.com/emersion/go-imap-sortthread"
	"github.com/emersion/go-imap/client"
	"golang.org/x/oauth2"

	"git.sr.ht/~rjarry/aerc/lib"
	"git.sr.ht/~rjarry/aerc/models"
	"git.sr.ht/~rjarry/aerc/worker/handlers"
	"git.sr.ht/~rjarry/aerc/worker/types"
)

func init() {
	handlers.RegisterWorkerFactory("imap", NewIMAPWorker)
	handlers.RegisterWorkerFactory("imaps", NewIMAPWorker)
}

var errUnsupported = fmt.Errorf("unsupported command")

type imapClient struct {
	*client.Client
	thread *sortthread.ThreadClient
	sort   *sortthread.SortClient
}

type IMAPWorker struct {
	config struct {
		scheme      string
		insecure    bool
		addr        string
		user        *url.Userinfo
		folders     []string
		oauthBearer lib.OAuthBearer
		// tcp connection parameters
		connection_timeout time.Duration
		keepalive_period   time.Duration
		keepalive_probes   int
		keepalive_interval int
	}

	client   *imapClient
	idleStop chan struct{}
	idleDone chan error
	selected *imap.MailboxStatus
	updates  chan client.Update
	worker   *types.Worker
	// Map of sequence numbers to UIDs, index 0 is seq number 1
	seqMap []uint32
}

func NewIMAPWorker(worker *types.Worker) (types.Backend, error) {
	return &IMAPWorker{
		idleDone: make(chan error),
		updates:  make(chan client.Update, 50),
		worker:   worker,
		selected: &imap.MailboxStatus{},
	}, nil
}

func (w *IMAPWorker) handleMessage(msg types.WorkerMessage) error {
	if w.client != nil && w.client.State() == imap.SelectedState {
		close(w.idleStop)
		if err := <-w.idleDone; err != nil {
			w.worker.PostMessage(&types.Error{Error: err}, nil)
		}
	}

	var reterr error // will be returned at the end, needed to support idle

	switch msg := msg.(type) {
	case *types.Unsupported:
		// No-op
	case *types.Configure:
		u, err := url.Parse(msg.Config.Source)
		if err != nil {
			return err
		}

		w.config.scheme = u.Scheme
		if strings.HasSuffix(w.config.scheme, "+insecure") {
			w.config.scheme = strings.TrimSuffix(w.config.scheme, "+insecure")
			w.config.insecure = true
		}

		if strings.HasSuffix(w.config.scheme, "+oauthbearer") {
			w.config.scheme = strings.TrimSuffix(w.config.scheme, "+oauthbearer")
			w.config.oauthBearer.Enabled = true
			q := u.Query()

			oauth2 := &oauth2.Config{}
			if q.Get("token_endpoint") != "" {
				oauth2.ClientID = q.Get("client_id")
				oauth2.ClientSecret = q.Get("client_secret")
				oauth2.Scopes = []string{q.Get("scope")}
				oauth2.Endpoint.TokenURL = q.Get("token_endpoint")
			}
			w.config.oauthBearer.OAuth2 = oauth2
		}

		w.config.addr = u.Host
		if !strings.ContainsRune(w.config.addr, ':') {
			w.config.addr += ":" + w.config.scheme
		}

		w.config.user = u.User
		w.config.folders = msg.Config.Folders
		w.config.connection_timeout = 30 * time.Second
		w.config.keepalive_period = 0 * time.Second
		w.config.keepalive_probes = 3
		w.config.keepalive_interval = 3
		for key, value := range msg.Config.Params {
			switch key {
			case "connection-timeout":
				val, err := time.ParseDuration(value)
				if err != nil || val < 0 {
					return fmt.Errorf(
						"invalid connection-timeout value %v: %v",
						value, err)
				}
				w.config.connection_timeout = val
			case "keepalive-period":
				val, err := time.ParseDuration(value)
				if err != nil || val < 0 {
					return fmt.Errorf(
						"invalid keepalive-period value %v: %v",
						value, err)
				}
				w.config.keepalive_period = val
			case "keepalive-probes":
				val, err := strconv.Atoi(value)
				if err != nil || val < 0 {
					return fmt.Errorf(
						"invalid keepalive-probes value %v: %v",
						value, err)
				}
				w.config.keepalive_probes = val
			case "keepalive-interval":
				val, err := time.ParseDuration(value)
				if err != nil || val < 0 {
					return fmt.Errorf(
						"invalid keepalive-interval value %v: %v",
						value, err)
				}
				w.config.keepalive_interval = int(val.Seconds())
			}
		}
	case *types.Connect:
		if w.client != nil && w.client.State() == imap.SelectedState {
			return fmt.Errorf("Already connected")
		}
		c, err := w.connect()
		if err != nil {
			return err
		}

		c.Updates = w.updates
		w.client = &imapClient{c, sortthread.NewThreadClient(c), sortthread.NewSortClient(c)}
		w.worker.PostMessage(&types.Done{types.RespondTo(msg)}, nil)
	case *types.Disconnect:
		if w.client == nil || w.client.State() != imap.SelectedState {
			return fmt.Errorf("Not connected")
		}
		if err := w.client.Logout(); err != nil {
			return err
		}
		w.worker.PostMessage(&types.Done{types.RespondTo(msg)}, nil)
	case *types.ListDirectories:
		w.handleListDirectories(msg)
	case *types.OpenDirectory:
		w.handleOpenDirectory(msg)
	case *types.FetchDirectoryContents:
		w.handleFetchDirectoryContents(msg)
	case *types.FetchDirectoryThreaded:
		w.handleDirectoryThreaded(msg)
	case *types.CreateDirectory:
		w.handleCreateDirectory(msg)
	case *types.RemoveDirectory:
		w.handleRemoveDirectory(msg)
	case *types.FetchMessageHeaders:
		w.handleFetchMessageHeaders(msg)
	case *types.FetchMessageBodyPart:
		w.handleFetchMessageBodyPart(msg)
	case *types.FetchFullMessages:
		w.handleFetchFullMessages(msg)
	case *types.DeleteMessages:
		w.handleDeleteMessages(msg)
	case *types.FlagMessages:
		w.handleFlagMessages(msg)
	case *types.AnsweredMessages:
		w.handleAnsweredMessages(msg)
	case *types.CopyMessages:
		w.handleCopyMessages(msg)
	case *types.AppendMessage:
		w.handleAppendMessage(msg)
	case *types.SearchDirectory:
		w.handleSearchDirectory(msg)
	default:
		reterr = errUnsupported
	}

	if w.client != nil && w.client.State() == imap.SelectedState {
		w.idleStop = make(chan struct{})
		go func() {
			w.idleDone <- w.client.Idle(w.idleStop, &client.IdleOptions{0, 0})
		}()
	}
	return reterr
}

func (w *IMAPWorker) handleImapUpdate(update client.Update) {
	w.worker.Logger.Printf("(= %T", update)
	switch update := update.(type) {
	case *client.MailboxUpdate:
		status := update.Mailbox
		if w.selected.Name == status.Name {
			w.selected = status
		}
		w.worker.PostMessage(&types.DirectoryInfo{
			Info: &models.DirectoryInfo{
				Flags:    status.Flags,
				Name:     status.Name,
				ReadOnly: status.ReadOnly,

				Exists: int(status.Messages),
				Recent: int(status.Recent),
				Unseen: int(status.Unseen),
			},
		}, nil)
	case *client.MessageUpdate:
		msg := update.Message
		if msg.Uid == 0 {
			msg.Uid = w.seqMap[msg.SeqNum-1]
		}
		w.worker.PostMessage(&types.MessageInfo{
			Info: &models.MessageInfo{
				BodyStructure: translateBodyStructure(msg.BodyStructure),
				Envelope:      translateEnvelope(msg.Envelope),
				Flags:         translateImapFlags(msg.Flags),
				InternalDate:  msg.InternalDate,
				Uid:           msg.Uid,
			},
		}, nil)
	case *client.ExpungeUpdate:
		i := update.SeqNum - 1
		uid := w.seqMap[i]
		w.seqMap = append(w.seqMap[:i], w.seqMap[i+1:]...)
		w.worker.PostMessage(&types.MessagesDeleted{
			Uids: []uint32{uid},
		}, nil)
	}
}

func (w *IMAPWorker) connect() (*client.Client, error) {
	var (
		conn *net.TCPConn
		c    *client.Client
	)

	addr, err := net.ResolveTCPAddr("tcp", w.config.addr)
	if err != nil {
		return nil, err
	}

	conn, err = net.DialTCP("tcp", nil, addr)
	if err != nil {
		return nil, err
	}

	if w.config.connection_timeout > 0 {
		end := time.Now().Add(w.config.connection_timeout)
		err = conn.SetDeadline(end)
		if err != nil {
			return nil, err
		}
	}
	if w.config.keepalive_period > 0 {
		err = w.setKeepaliveParameters(conn)
		if err != nil {
			return nil, err
		}
	}

	serverName, _, _ := net.SplitHostPort(w.config.addr)
	tlsConfig := &tls.Config{ServerName: serverName}

	switch w.config.scheme {
	case "imap":
		c, err = client.New(conn)
		if err != nil {
			return nil, err
		}
		if !w.config.insecure {
			if err = c.StartTLS(tlsConfig); err != nil {
				return nil, err
			}
		}
	case "imaps":
		tlsConn := tls.Client(conn, tlsConfig)
		c, err = client.New(tlsConn)
		if err != nil {
			return nil, err
		}
	default:
		return nil, fmt.Errorf("Unknown IMAP scheme %s", w.config.scheme)
	}

	c.ErrorLog = w.worker.Logger

	if w.config.user != nil {
		username := w.config.user.Username()
		password, hasPassword := w.config.user.Password()
		if !hasPassword {
			// TODO: ask password
		}

		if w.config.oauthBearer.Enabled {
			if err := w.config.oauthBearer.Authenticate(
				username, password, c); err != nil {
				return nil, err
			}
		} else if err := c.Login(username, password); err != nil {
			return nil, err
		}
	}

	c.SetDebug(w.worker.Logger.Writer())

	if _, err := c.Select(imap.InboxName, false); err != nil {
		return nil, err
	}

	return c, nil
}

// Set additional keepalive parameters.
// Uses new interfaces introduced in Go1.11, which let us get connection's file
// descriptor, without blocking, and therefore without uncontrolled spawning of
// threads (not goroutines, actual threads).
func (w *IMAPWorker) setKeepaliveParameters(conn *net.TCPConn) error {
	err := conn.SetKeepAlive(true)
	if err != nil {
		return err
	}
	// Idle time before sending a keepalive probe
	err = conn.SetKeepAlivePeriod(w.config.keepalive_period)
	if err != nil {
		return err
	}
	rawConn, e := conn.SyscallConn()
	if e != nil {
		return e
	}
	err = rawConn.Control(func(fdPtr uintptr) {
		fd := int(fdPtr)
		// Max number of probes before failure
		err := syscall.SetsockoptInt(
			fd, syscall.IPPROTO_TCP, syscall.TCP_KEEPCNT,
			w.config.keepalive_probes)
		if err != nil {
			w.worker.Logger.Printf(
				"cannot set tcp keepalive probes: %v\n", err)
		}
		// Wait time after an unsuccessful probe
		err = syscall.SetsockoptInt(
			fd, syscall.IPPROTO_TCP, syscall.TCP_KEEPINTVL,
			w.config.keepalive_interval)
		if err != nil {
			w.worker.Logger.Printf(
				"cannot set tcp keepalive interval: %v\n", err)
		}
	})
	return err
}

func (w *IMAPWorker) Run() {
	for {
		select {
		case msg := <-w.worker.Actions:
			msg = w.worker.ProcessAction(msg)
			if err := w.handleMessage(msg); err == errUnsupported {
				w.worker.PostMessage(&types.Unsupported{
					Message: types.RespondTo(msg),
				}, nil)
			} else if err != nil {
				w.worker.PostMessage(&types.Error{
					Message: types.RespondTo(msg),
					Error:   err,
				}, nil)
			}
		case update := <-w.updates:
			w.handleImapUpdate(update)
		}
	}
}