-
Notifications
You must be signed in to change notification settings - Fork 0
/
pop3.go
264 lines (209 loc) · 6.03 KB
/
pop3.go
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
//Copyright 2011, Andreas Sinz
// Use of this source code is governed by the GPLv2
// license that can be found in the LICENSE file.
//Implements the Post Office Protocol 3 as defined in RFC 1939
package pop3
import (
"bufio"
"errors"
"fmt"
"net"
"strconv"
"strings"
"crypto/tls"
)
const (
//Carriage Return + Line Feed
//CRLF is appended at the end of each commands
CRLF = "\r\n"
//POP3-Commands
USER = "USER"
PASSWORD = "PASS"
NOOP = "NOOP"
RESET = "RSET"
DELETE = "DELE"
QUIT = "QUIT"
STATUS = "STAT"
LIST = "LIST"
RETRIEVE = "RETR"
)
var (
IndexERR = errors.New("Index must be greater than zero")
UnkownResponseERR = errors.New("Unkown Response received")
)
type Client struct {
conn net.Conn
stream *bufio.ReadWriter
ServerName string
Greeting string
}
//Returns a new Client connected to a POP3 server at addr.
//The format of addr is "ip:port" or "hostname:port"
func Dial(addr string) (client *Client, err error) {
conn, err := net.Dial("tcp", addr)
if err != nil {
return nil, err
}
host := addr[:strings.Index(addr, ":")]
return NewClient(conn, host)
}
func DialTLS(addr string) (client *Client, err error) {
conn, err := tls.Dial("tcp", addr, nil)
if err != nil {
return nil, err
}
host := addr[:strings.Index(addr, ":")]
return NewClient(conn, host)
}
//NewClient returns a new Client using an existing connection
//name is used as the Servername
func NewClient(conn net.Conn, name string) (*Client, error) {
client := new(Client)
//Create a new ReadWriter and store it
stream := bufio.NewReadWriter(bufio.NewReader(conn), bufio.NewWriter(conn))
client.stream = stream
//Download the greeting from the POP3 server
msg, err := client.readMessage(false)
if err != nil {
return nil, err
}
client.ServerName = name
client.Greeting = msg[4:]
return client, nil
}
//Sends a command to the POP3-Server and returns the response or an error
func (client *Client) Command(command string, isResponseMultiLine bool) (string, error) {
//Check, whether the client connection has already been
if client == nil {
return "", errors.New("Connection hasn't been established")
}
//Send the command to the server
tmp := command + CRLF
_, writeErr := client.stream.WriteString(tmp)
if writeErr != nil {
return "", writeErr
}
client.stream.Flush()
return client.readMessage(isResponseMultiLine)
}
//Returns the response of the pop3 server, or an error if any
func (client *Client) readMessage(isResponseMultiLine bool) (string, error) {
//Get first line of the response
msg, err := client.stream.ReadString('\n')
if err != nil {
return "", err
}
//Check, whether the response starts with "+OK" or "-ERR", otherwise return an error
if strings.HasPrefix(msg, "+OK") {
msg = msg[4:]
if isResponseMultiLine {
for true {
line, err1 := client.stream.ReadString('\n')
if err1 != nil {
return "", err1
}
if line == "."+CRLF {
break
}
msg += line
}
}
} else if strings.HasPrefix(msg, "-ERR") {
return "", errors.New(msg[5:])
} else {
return "", UnkownResponseERR
}
return msg, nil
}
//Authenticates with the Server
//It uses the provided Authenticationtype auth
func (client *Client) Authenticate(auth Auth) error {
return auth.Authenticate(client)
}
//Sends a "NOOP" command and the server will just reply with a positive response
func (client *Client) Ping() (err error) {
_, err = client.Command(NOOP, false)
return
}
//Messages that have been marked as "deleted" will be unmarked after this command
func (client *Client) Reset() (string, error) {
return client.Command(RESET, false)
}
//Mark a mail as "deleted"
//All marked mails will be deleted, when you close the connection with "QUIT"
func (client *Client) MarkMailAsDeleted(index int) (string, error) {
if index < 0 {
return "", IndexERR
}
return client.Command(fmt.Sprintf("%s %d", DELETE, index), false)
}
//Issues the Quit-Command, so the POP3 session enters the UPDATE state
//All mails, which are marked as "deleted", are going to be removed now
func (client *Client) Quit() (string, error) {
return client.Command(QUIT, false)
}
//Retrieves the count of mails and the size of all those mails in the mailbox
//Mails, which are marked as "deleted", won't show up
func (client *Client) GetStatus() (mailCount, mailBoxSize int, err error) {
response, cmdErr := client.Command(STATUS, false)
if cmdErr != nil {
return -1, -1, cmdErr
}
digits := getDigitsFromLine(response)
if len(digits) == 2 {
mailCount = digits[0]
mailBoxSize = digits[1]
} else {
err = UnkownResponseERR
}
return
}
//Returns a list of mails
//First digit is the index of the mail, then a whitespace and the size in octets
func (client *Client) GetRawMailList() (response string, err error) {
if response, err = client.Command(LIST, true); err != nil {
return
}
//Just return the list of mails, not the header
response = response[strings.Index(response, "\n"):]
return
}
//Returns the index and the size of the mail at index
func (client *Client) GetMailStatus(index int) (mailIndex, mailSize int, err error) {
cmdString := fmt.Sprintf("%s %d", LIST, index)
response, cmdErr := client.Command(cmdString, false)
if cmdErr != nil {
return -1, -1, cmdErr
}
digits := getDigitsFromLine(response)
if len(digits) == 2 {
mailIndex = digits[0]
mailSize = digits[1]
} else {
err = UnkownResponseERR
}
return
}
//Retrieves the raw mail at index as a string
//This string contains the whole header and the body of the mail
func (client *Client) GetRawMail(index int) (mail string, err error) {
if index < 1 {
return "", IndexERR
}
mail, err = client.Command(fmt.Sprintf("%s %d", RETRIEVE, index), true)
if err != nil {
return
}
//Remove the first line
mail = mail[strings.Index(mail, "\n"):]
return
}
//Returns every digit, which exists in the string
func getDigitsFromLine(line string) (digits []int) {
for _, part := range strings.Split(line, " ") {
if tmp, convertErr := strconv.Atoi(strings.TrimSpace(part)); convertErr == nil {
digits = append(digits, tmp)
}
}
return
}