package mail

Import Path
	net/mail (on go.dev)

Dependency Relation
	imports 12 packages, and imported by 0 packages


Involved Source Files

	
		Package mail implements parsing of mail messages.
		
		For the most part, this package follows the syntax as specified by RFC 5322 and
		extended by RFC 6532.
		Notable divergences:
		  - Obsolete address formats are not parsed, including addresses with
		    embedded route information.
		  - The full range of spacing (the CFWS syntax element) is not supported,
		    such as breaking addresses across lines.
		  - No unicode normalization is performed.
		  - A leading From line is permitted, as in mbox format (RFC 4155).


Code Examples

	
		package main
		
		import (
			"fmt"
			"log"
			"net/mail"
		)
		
		func main() {
			e, err := mail.ParseAddress("Alice <alice@example.com>")
			if err != nil {
				log.Fatal(err)
			}
		
			fmt.Println(e.Name, e.Address)
		
		}

	
		package main
		
		import (
			"fmt"
			"log"
			"net/mail"
		)
		
		func main() {
			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)
			}
		
		}

	
		package main
		
		import (
			"fmt"
			"io"
			"log"
			"net/mail"
			"strings"
		)
		
		func main() {
			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)
		
		}




Package-Level Type Names (total 4)


	/* sort by:  |  */
	
		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"}.

		
			
				// user@domain

			
				// Proper name; may be empty.

		
			
				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.

		
			*Address : expvar.Var
			*Address : fmt.Stringer
		
			func ParseAddress(address string) (*Address, error)
			func ParseAddressList(list string) ([]*Address, error)
			func (*AddressParser).Parse(address string) (*Address, error)
			func (*AddressParser).ParseList(list string) ([]*Address, error)
			func Header.AddressList(key string) ([]*Address, error)


	
		An AddressParser is an RFC 5322 address parser.

		
			
				WordDecoder optionally specifies a decoder for RFC 2047 encoded-words.

		
			
				Parse parses a single RFC 5322 address of the
				form "Gogh Fir <gf@example.com>" or "foo@example.com".

			
				ParseList parses the given string as a list of comma-separated addresses
				of the form "Gogh Fir <gf@example.com>" or "foo@example.com".



	
		A Header represents the key-value pairs in a mail message header.

		
			
				AddressList parses the named header field as a list of addresses.

			
				Date parses the Date header field.

			
				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.



	
		A Message represents a parsed mail message.

		
			Body io.Reader
			Header Header
		
			func ReadMessage(r io.Reader) (msg *Message, err error)




Package-Level Functions (total 4)


	
		ParseAddress parses a single RFC 5322 address, e.g. "Barry Gibbs <bg@example.com>"


	
		ParseAddressList parses the given string as a list of addresses.


	
		ParseDate parses an RFC 5322 date string.


	
		ReadMessage reads a message from r.
		The headers are parsed, and the body of the message will be available
		for reading from msg.Body.




Package-Level Variables (only one)