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
|
package koushincarddav
import (
"fmt"
"net/http"
"net/url"
"git.sr.ht/~emersion/koushin"
koushinbase "git.sr.ht/~emersion/koushin/plugins/base"
"github.com/emersion/go-vcard"
"github.com/emersion/go-webdav/carddav"
)
func sanityCheckURL(u *url.URL) error {
req, err := http.NewRequest(http.MethodOptions, u.String(), nil)
if err != nil {
return err
}
resp, err := http.DefaultClient.Do(req)
if err != nil {
return err
}
resp.Body.Close()
// Servers might require authentication to perform an OPTIONS request
if resp.StatusCode/100 != 2 && resp.StatusCode != http.StatusUnauthorized {
return fmt.Errorf("HTTP request failed: %v %v", resp.StatusCode, resp.Status)
}
return nil
}
type plugin struct {
koushin.GoPlugin
url *url.URL
homeSetCache map[string]string
}
func (p *plugin) clientWithAddressBook(session *koushin.Session) (*carddav.Client, *carddav.AddressBook, error) {
c, err := newClient(p.url, session)
if err != nil {
return nil, nil, fmt.Errorf("failed to create CardDAV client: %v", err)
}
homeSet, ok := p.homeSetCache[session.Username()]
if !ok {
principal, err := c.FindCurrentUserPrincipal()
if err != nil {
return nil, nil, fmt.Errorf("failed to query CardDAV principal: %v", err)
}
homeSet, err = c.FindAddressBookHomeSet(principal)
if err != nil {
return nil, nil, fmt.Errorf("failed to query CardDAV address book home set: %v", err)
}
p.homeSetCache[session.Username()] = homeSet
// TODO: evict entries from the cache if it's getting too big
}
addressBooks, err := c.FindAddressBooks(homeSet)
if err != nil {
return nil, nil, fmt.Errorf("failed to query CardDAV address books: %v", err)
}
if len(addressBooks) == 0 {
return nil, nil, errNoAddressBook
}
return c, &addressBooks[0], nil
}
func newPlugin(srv *koushin.Server) (koushin.Plugin, error) {
u, err := srv.Upstream("carddavs", "carddav+insecure", "https", "http+insecure")
if _, ok := err.(*koushin.NoUpstreamError); ok {
return nil, nil
} else if err != nil {
return nil, fmt.Errorf("carddav: failed to parse upstream CardDAV server: %v", err)
}
switch u.Scheme {
case "carddavs":
u.Scheme = "https"
case "carddav+insecure", "http+insecure":
u.Scheme = "http"
}
if u.Scheme == "" {
s, err := carddav.Discover(u.Host)
if err != nil {
srv.Logger().Printf("carddav: failed to discover CardDAV server: %v", err)
return nil, nil
}
u, err = url.Parse(s)
if err != nil {
return nil, fmt.Errorf("carddav: Discover returned an invalid URL: %v", err)
}
}
if err := sanityCheckURL(u); err != nil {
return nil, fmt.Errorf("carddav: failed to connect to CardDAV server %q: %v", u, err)
}
srv.Logger().Printf("Configured upstream CardDAV server: %v", u)
p := &plugin{
GoPlugin: koushin.GoPlugin{Name: "carddav"},
url: u,
homeSetCache: make(map[string]string),
}
registerRoutes(p)
p.Inject("compose.html", func(ctx *koushin.Context, _data koushin.RenderData) error {
data := _data.(*koushinbase.ComposeRenderData)
c, addressBook, err := p.clientWithAddressBook(ctx.Session)
if err == errNoAddressBook {
return nil
} else if err != nil {
return err
}
query := carddav.AddressBookQuery{
DataRequest: carddav.AddressDataRequest{
Props: []string{vcard.FieldFormattedName, vcard.FieldEmail},
},
PropFilters: []carddav.PropFilter{{
Name: vcard.FieldEmail,
}},
}
addrs, err := c.QueryAddressBook(addressBook.Path, &query)
if err != nil {
return fmt.Errorf("failed to query CardDAV addresses: %v", err)
}
// TODO: cache the results
emails := make([]string, 0, len(addrs))
for _, addr := range addrs {
cardEmails := addr.Card.Values(vcard.FieldEmail)
emails = append(emails, cardEmails...)
}
data.Extra["EmailSuggestions"] = emails
return nil
})
return p.Plugin(), nil
}
func init() {
koushin.RegisterPluginLoader(func(s *koushin.Server) ([]koushin.Plugin, error) {
p, err := newPlugin(s)
if err != nil {
return nil, err
}
if p == nil {
return nil, nil
}
return []koushin.Plugin{p}, err
})
}
|
