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
|
package proton
import (
"bytes"
"io"
"net/mail"
"github.com/ProtonMail/gluon/rfc822"
"github.com/ProtonMail/go-crypto/openpgp/armor"
"github.com/ProtonMail/gopenpgp/v2/crypto"
"golang.org/x/exp/slices"
)
type MessageMetadata struct {
ID string
AddressID string
LabelIDs []string
ExternalID string
Subject string
Sender *mail.Address
ToList []*mail.Address
CCList []*mail.Address
BCCList []*mail.Address
ReplyTos []*mail.Address
Flags MessageFlag
Time int64
Size int
Unread Bool
IsReplied Bool
IsRepliedAll Bool
IsForwarded Bool
NumAttachments int
}
func (meta MessageMetadata) Seen() bool {
return !bool(meta.Unread)
}
func (meta MessageMetadata) Starred() bool {
return slices.Contains(meta.LabelIDs, StarredLabel)
}
func (meta MessageMetadata) IsDraft() bool {
return meta.Flags&(MessageFlagReceived|MessageFlagSent) == 0
}
type MessageFilter struct {
ID []string `json:",omitempty"`
Subject string `json:",omitempty"`
AddressID string `json:",omitempty"`
ExternalID string `json:",omitempty"`
LabelID string `json:",omitempty"`
EndID string `json:",omitempty"`
Desc Bool
}
type Message struct {
MessageMetadata
Header string
ParsedHeaders Headers
Body string
MIMEType rfc822.MIMEType
Attachments []Attachment
}
type MessageFlag int64
const (
MessageFlagReceived MessageFlag = 1 << 0
MessageFlagSent MessageFlag = 1 << 1
MessageFlagInternal MessageFlag = 1 << 2
MessageFlagE2E MessageFlag = 1 << 3
MessageFlagAuto MessageFlag = 1 << 4
MessageFlagReplied MessageFlag = 1 << 5
MessageFlagRepliedAll MessageFlag = 1 << 6
MessageFlagForwarded MessageFlag = 1 << 7
MessageFlagAutoReplied MessageFlag = 1 << 8
MessageFlagImported MessageFlag = 1 << 9
MessageFlagOpened MessageFlag = 1 << 10
MessageFlagReceiptSent MessageFlag = 1 << 11
MessageFlagNotified MessageFlag = 1 << 12
MessageFlagTouched MessageFlag = 1 << 13
MessageFlagReceipt MessageFlag = 1 << 14
MessageFlagReceiptRequest MessageFlag = 1 << 16
MessageFlagPublicKey MessageFlag = 1 << 17
MessageFlagSign MessageFlag = 1 << 18
MessageFlagUnsubscribed MessageFlag = 1 << 19
MessageFlagScheduledSend MessageFlag = 1 << 20
MessageFlagAlias MessageFlag = 1 << 21
MessageFlagDMARCPass MessageFlag = 1 << 23
MessageFlagSPFFail MessageFlag = 1 << 24
MessageFlagDKIMFail MessageFlag = 1 << 25
MessageFlagDMARCFail MessageFlag = 1 << 26
MessageFlagHamManual MessageFlag = 1 << 27
MessageFlagSpamAuto MessageFlag = 1 << 28
MessageFlagSpamManual MessageFlag = 1 << 29
MessageFlagPhishingAuto MessageFlag = 1 << 30
MessageFlagPhishingManual MessageFlag = 1 << 31
)
func (f MessageFlag) Has(flag MessageFlag) bool {
return f&flag != 0
}
func (f MessageFlag) Matches(flag MessageFlag) bool {
return f&flag == flag
}
func (f MessageFlag) HasAny(flags ...MessageFlag) bool {
for _, flag := range flags {
if f.Has(flag) {
return true
}
}
return false
}
func (f MessageFlag) HasAll(flags ...MessageFlag) bool {
for _, flag := range flags {
if !f.Has(flag) {
return false
}
}
return true
}
func (f MessageFlag) Add(flag MessageFlag) MessageFlag {
return f | flag
}
func (f MessageFlag) Remove(flag MessageFlag) MessageFlag {
return f &^ flag
}
func (f MessageFlag) Toggle(flag MessageFlag) MessageFlag {
if f.Has(flag) {
return f.Remove(flag)
}
return f.Add(flag)
}
func (m Message) Decrypt(kr *crypto.KeyRing) ([]byte, error) {
enc, err := crypto.NewPGPMessageFromArmored(m.Body)
if err != nil {
return nil, err
}
dec, err := kr.Decrypt(enc, nil, crypto.GetUnixTime())
if err != nil {
return nil, err
}
return dec.GetBinary(), nil
}
func (m Message) DecryptInto(kr *crypto.KeyRing, buffer io.ReaderFrom) error {
armored, err := armor.Decode(bytes.NewReader([]byte(m.Body)))
if err != nil {
return err
}
stream, err := kr.DecryptStream(armored.Body, nil, crypto.GetUnixTime())
if err != nil {
return err
}
if _, err := buffer.ReadFrom(stream); err != nil {
return err
}
return nil
}
type FullMessage struct {
Message
AttData [][]byte
}
type Signature struct {
Hash string
Data *crypto.PGPSignature
}
type MessageActionReq struct {
IDs []string
}
type LabelMessagesReq struct {
LabelID string
IDs []string
}
type LabelMessagesRes struct {
Responses []LabelMessageRes
UndoToken UndoToken
}
func (res LabelMessagesRes) ok() (bool, string) {
for _, resp := range res.Responses {
if resp.Response.Code != SuccessCode {
return false, resp.Response.Error()
}
}
return true, ""
}
type LabelMessageRes struct {
ID string
Response APIError
}
type MessageGroupCount struct {
LabelID string
Total int
Unread int
}
|
