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
|
<h1> Package mail </h1> <ul id="short-nav">
<li><code>import "net/mail"</code></li>
<li><a href="#pkg-overview" class="overviewLink">Overview</a></li>
<li><a href="#pkg-index" class="indexLink">Index</a></li>
<li><a href="#pkg-examples" class="examplesLink">Examples</a></li>
</ul> <h2 id="pkg-overview">Overview </h2> <p>Package mail implements parsing of mail messages. </p>
<p>For the most part, this package follows the syntax as specified by RFC 5322 and extended by RFC 6532. Notable divergences: </p>
<ul> <li>Obsolete address formats are not parsed, including addresses with embedded route information. </li>
<li>The full range of spacing (the CFWS syntax element) is not supported, such as breaking addresses across lines. </li>
<li>No unicode normalization is performed. </li>
<li>The special characters ()[]:;@\, are allowed to appear unquoted in names. </li>
<li>A leading From line is permitted, as in mbox format (RFC 4155). </li>
</ul> <h2 id="pkg-index">Index </h2> <ul id="manual-nav">
<li><a href="#pkg-variables">Variables</a></li>
<li><a href="#ParseDate">func ParseDate(date string) (time.Time, error)</a></li>
<li><a href="#Address">type Address</a></li>
<li> <a href="#ParseAddress">func ParseAddress(address string) (*Address, error)</a>
</li>
<li> <a href="#ParseAddressList">func ParseAddressList(list string) ([]*Address, error)</a>
</li>
<li> <a href="#Address.String">func (a *Address) String() string</a>
</li>
<li><a href="#AddressParser">type AddressParser</a></li>
<li> <a href="#AddressParser.Parse">func (p *AddressParser) Parse(address string) (*Address, error)</a>
</li>
<li> <a href="#AddressParser.ParseList">func (p *AddressParser) ParseList(list string) ([]*Address, error)</a>
</li>
<li><a href="#Header">type Header</a></li>
<li> <a href="#Header.AddressList">func (h Header) AddressList(key string) ([]*Address, error)</a>
</li>
<li> <a href="#Header.Date">func (h Header) Date() (time.Time, error)</a>
</li>
<li> <a href="#Header.Get">func (h Header) Get(key string) string</a>
</li>
<li><a href="#Message">type Message</a></li>
<li> <a href="#ReadMessage">func ReadMessage(r io.Reader) (msg *Message, err error)</a>
</li>
</ul> <div id="pkg-examples"> <h3>Examples</h3> <dl> <dd><a class="exampleLink" href="#example_ParseAddress">ParseAddress</a></dd> <dd><a class="exampleLink" href="#example_ParseAddressList">ParseAddressList</a></dd> <dd><a class="exampleLink" href="#example_ReadMessage">ReadMessage</a></dd> </dl> </div> <h3>Package files</h3> <p> <span>message.go</span> </p> <h2 id="pkg-variables">Variables</h2> <pre data-language="go">var ErrHeaderNotPresent = errors.New("mail: header not in message")</pre> <h2 id="ParseDate">func <span>ParseDate</span> <span title="Added in Go 1.8">1.8</span> </h2> <pre data-language="go">func ParseDate(date string) (time.Time, error)</pre> <p>ParseDate parses an RFC 5322 date string. </p>
<h2 id="Address">type <span>Address</span> </h2> <p>Address represents a single mail address. An address such as "Barry Gibbs <bg@example.com>" is represented as Address{Name: "Barry Gibbs", Address: "bg@example.com"}. </p>
<pre data-language="go">type Address struct {
Name string // Proper name; may be empty.
Address string // user@domain
}
</pre> <h3 id="ParseAddress">func <span>ParseAddress</span> <span title="Added in Go 1.1">1.1</span> </h3> <pre data-language="go">func ParseAddress(address string) (*Address, error)</pre> <p>ParseAddress parses a single RFC 5322 address, e.g. "Barry Gibbs <bg@example.com>" </p> <h4 id="example_ParseAddress"> <span class="text">Example</span>
</h4> <p>Code:</p> <pre class="code" data-language="go">e, err := mail.ParseAddress("Alice <alice@example.com>")
if err != nil {
log.Fatal(err)
}
fmt.Println(e.Name, e.Address)
</pre> <p>Output:</p> <pre class="output" data-language="go">Alice alice@example.com
</pre> <h3 id="ParseAddressList">func <span>ParseAddressList</span> <span title="Added in Go 1.1">1.1</span> </h3> <pre data-language="go">func ParseAddressList(list string) ([]*Address, error)</pre> <p>ParseAddressList parses the given string as a list of addresses. </p> <h4 id="example_ParseAddressList"> <span class="text">Example</span>
</h4> <p>Code:</p> <pre class="code" data-language="go">const list = "Alice <alice@example.com>, Bob <bob@example.com>, Eve <eve@example.com>"
emails, err := mail.ParseAddressList(list)
if err != nil {
log.Fatal(err)
}
for _, v := range emails {
fmt.Println(v.Name, v.Address)
}
</pre> <p>Output:</p> <pre class="output" data-language="go">Alice alice@example.com
Bob bob@example.com
Eve eve@example.com
</pre> <h3 id="Address.String">func (*Address) <span>String</span> </h3> <pre data-language="go">func (a *Address) String() string</pre> <p>String formats the address as a valid RFC 5322 address. If the address's name contains non-ASCII characters the name will be rendered according to RFC 2047. </p>
<h2 id="AddressParser">type <span>AddressParser</span> <span title="Added in Go 1.5">1.5</span> </h2> <p>An AddressParser is an RFC 5322 address parser. </p>
<pre data-language="go">type AddressParser struct {
// WordDecoder optionally specifies a decoder for RFC 2047 encoded-words.
WordDecoder *mime.WordDecoder
}
</pre> <h3 id="AddressParser.Parse">func (*AddressParser) <span>Parse</span> <span title="Added in Go 1.5">1.5</span> </h3> <pre data-language="go">func (p *AddressParser) Parse(address string) (*Address, error)</pre> <p>Parse parses a single RFC 5322 address of the form "Gogh Fir <gf@example.com>" or "foo@example.com". </p>
<h3 id="AddressParser.ParseList">func (*AddressParser) <span>ParseList</span> <span title="Added in Go 1.5">1.5</span> </h3> <pre data-language="go">func (p *AddressParser) ParseList(list string) ([]*Address, error)</pre> <p>ParseList parses the given string as a list of comma-separated addresses of the form "Gogh Fir <gf@example.com>" or "foo@example.com". </p>
<h2 id="Header">type <span>Header</span> </h2> <p>A Header represents the key-value pairs in a mail message header. </p>
<pre data-language="go">type Header map[string][]string</pre> <h3 id="Header.AddressList">func (Header) <span>AddressList</span> </h3> <pre data-language="go">func (h Header) AddressList(key string) ([]*Address, error)</pre> <p>AddressList parses the named header field as a list of addresses. </p>
<h3 id="Header.Date">func (Header) <span>Date</span> </h3> <pre data-language="go">func (h Header) Date() (time.Time, error)</pre> <p>Date parses the Date header field. </p>
<h3 id="Header.Get">func (Header) <span>Get</span> </h3> <pre data-language="go">func (h Header) Get(key string) string</pre> <p>Get gets the first value associated with the given key. It is case insensitive; CanonicalMIMEHeaderKey is used to canonicalize the provided key. If there are no values associated with the key, Get returns "". To access multiple values of a key, or to use non-canonical keys, access the map directly. </p>
<h2 id="Message">type <span>Message</span> </h2> <p>A Message represents a parsed mail message. </p>
<pre data-language="go">type Message struct {
Header Header
Body io.Reader
}
</pre> <h3 id="ReadMessage">func <span>ReadMessage</span> </h3> <pre data-language="go">func ReadMessage(r io.Reader) (msg *Message, err error)</pre> <p>ReadMessage reads a message from r. The headers are parsed, and the body of the message will be available for reading from msg.Body. </p> <h4 id="example_ReadMessage"> <span class="text">Example</span>
</h4> <p>Code:</p> <pre class="code" data-language="go">msg := `Date: Mon, 23 Jun 2015 11:40:36 -0400
From: Gopher <from@example.com>
To: Another Gopher <to@example.com>
Subject: Gophers at Gophercon
Message body
`
r := strings.NewReader(msg)
m, err := mail.ReadMessage(r)
if err != nil {
log.Fatal(err)
}
header := m.Header
fmt.Println("Date:", header.Get("Date"))
fmt.Println("From:", header.Get("From"))
fmt.Println("To:", header.Get("To"))
fmt.Println("Subject:", header.Get("Subject"))
body, err := io.ReadAll(m.Body)
if err != nil {
log.Fatal(err)
}
fmt.Printf("%s", body)
</pre> <p>Output:</p> <pre class="output" data-language="go">Date: Mon, 23 Jun 2015 11:40:36 -0400
From: Gopher <from@example.com>
To: Another Gopher <to@example.com>
Subject: Gophers at Gophercon
Message body
</pre><div class="_attribution">
<p class="_attribution-p">
© Google, Inc.<br>Licensed under the Creative Commons Attribution License 3.0.<br>
<a href="http://golang.org/pkg/net/mail/" class="_attribution-link">http://golang.org/pkg/net/mail/</a>
</p>
</div>
|
