As a powerful programming language, Golang performs particularly well in the field of network programming. When communicating over the network, Golang provides many convenient tools and libraries, one of which is the SMTP library. As a network transmission protocol, the SMTP protocol is used for sending and receiving emails and is an important part of network communication. In practical applications, it is sometimes necessary to forward received emails. This article will introduce how Golang implements the SMTP email forwarding function.
SMTP (Simple Mail Transfer Protocol) is a text-based mail transfer protocol used for sending and receiving emails. The SMTP protocol is one of the Internet standard protocols and is the core protocol for email sending. The SMTP protocol uses TCP as the underlying transmission protocol and port 25 as the transmission port.
SMTP contains the following basic concepts:
The SMTP protocol workflow is as follows:
Through Golang’s SMTP library, you can easily send emails. Golang's SMTP library implements the email sending function based on the SMTP protocol and provides a convenient API interface.
First, you need to use the Dial function provided in the SMTP library to connect to the SMTP server. This function needs to pass in the address and port number of the SMTP server, user name and password and other information.
func Dial(addr string, a Auth) (*Client, error)
Among them, the Auth type represents the authentication information of the SMTP server, including user name and password. The sample code to connect to the SMTP server is as follows:
import (
"net/smtp"
)
func main() {
// 创建认证信息
auth := smtp.PlainAuth("", "smtp_username", "smtp_password", "smtp_host")
// 连接SMTP服务器
client, err := smtp.Dial("smtp_host:smtp_port")
if err != nil {
panic(err)
}
// 登录SMTP服务器
err = client.Auth(auth)
if err != nil {
panic(err)
}
// 退出SMTP服务器
defer client.Quit()}
Connect After the SMTP server is successful, it can send email information to the server according to the requirements of the SMTP protocol. You need to use the Mail and Rcpt methods provided by the smtp library to send sender and recipient information. The sample codes for the Mail and Rcpt methods are as follows:
// Send sender information
func (c *Client) Mail(from string) error
// Send recipient Information
func (c *Client) Rcpt(to string) error
To send email information, you need to use the Data method provided by the smtp library to send the email content to the SMTP server. The sample code of the Data method is as follows:
// Send email content
func (c *Client) Data() (io.WriteCloser, error)
After sending the email, If the connection needs to be closed, use the Quit method to exit the SMTP server. The code is as follows:
//Exit the SMTP server
func (c *Client) Quit() error
In order to implement the email forwarding function, the email content needs to be forwarded to the designated recipient after the email is received. Therefore, you need to use the SMTP library in Golang to send the email content to the specified SMTP server and recipient.
The specific steps are as follows:
The specific implementation code is as follows:
import (
"bytes" "errors" "fmt" "log" "net" "net/smtp" "strings"
)
// Listening port
func ListenAndServe(addr string) error {
listener, err := net.Listen("tcp", addr)
if err != nil {
return err
}
defer listener.Close()
for {
conn, err := listener.Accept()
if err != nil {
log.Printf("Failed to accept connection (%s)", err)
continue
}
go handleConnection(conn)
}}
// Handle received emails
func handleConnection(conn net.Conn) {
defer conn.Close()
// 读取邮件内容
buf := make([]byte, 4096)
n, err := conn.Read(buf)
if err != nil {
log.Printf("Failed to read connection (%s)", err)
return
}
defer conn.Close()
// 解析邮件
message, err := parseMessage(buf[:n])
if err != nil {
log.Printf("Failed to parse message (%s)", err)
return
}
// 判断收件人和发件人是否符合要求
if !checkRecipient(message.Recipient) {
log.Printf("Invalid recipient (%s)", message.Recipient)
return
}
if !checkSender(message.Sender) {
log.Printf("Invalid sender (%s)", message.Sender)
return
}
// 构建SMTP客户端
auth := smtp.PlainAuth("", "smtp_username", "smtp_password", "smtp_host")
client, err := smtp.Dial("smtp_host:smtp_port")
if err != nil {
log.Printf("Failed to connect SMTP server (%s)", err)
return
}
defer client.Quit()
// 发送邮件内容
err = client.Mail("from_address")
if err != nil {
log.Printf("Failed to send 'MAIL FROM' command (%s)", err)
return
}
err = client.Rcpt(message.Recipient)
if err != nil {
log.Printf("Failed to send 'RCPT TO' command (%s)", err)
return
}
w, err := client.Data()
if err != nil {
log.Printf("Failed to send 'DATA' command (%s)", err)
return
}
defer w.Close()
buf.WriteString(fmt.Sprintf("To: %s\r\n", message.Recipient))
buf.WriteString(fmt.Sprintf("From: %s\r\n", message.Sender))
buf.WriteString(fmt.Sprintf("Subject: %s\r\n", message.Subject))
buf.WriteString("\r\n")
buf.WriteString(message.Body)
_, err = w.Write(buf.Bytes())
if err != nil {
log.Printf("Failed to write email to client (%s)", err)
return
}
log.Printf("Mail sent to %s", message.Recipient)}
// Parse the email content
func parseMessage(message []byte) (*Message, error) {
var msg Message
msg.Body = string(message)
// 提取发件人地址
start := bytes.Index(message, []byte("From: "))
if start == -1 {
return nil, errors.New("Failed to find 'From:' in message")
}
start += 6
end := bytes.Index(message[start:], []byte("\r\n"))
if end == -1 {
return nil, errors.New("Failed to find end of 'From:' in message")
}
msg.Sender = string(message[start : start+end])
// 提取收件人地址
start = bytes.Index(message, []byte("To: "))
if start == -1 {
return nil, errors.New("Failed to find 'To:' in message")
}
start += 4
end = bytes.Index(message[start:], []byte("\r\n"))
if end == -1 {
return nil, errors.New("Failed to find end of 'To:' in message")
}
msg.Recipient = string(message[start : start+end])
// 提取邮件主题
start = bytes.Index(message, []byte("Subject: "))
if start == -1 {
return nil, errors.New("Failed to find 'Subject:' in message")
}
start += 9
end = bytes.Index(message[start:], []byte("\r\n"))
if end == -1 {
return nil, errors.New("Failed to find end of 'Subject:' in message")
}
msg.Subject = string(message[start : start+end])
return &msg, nil}
// Verify whether the recipient is legitimate
func checkRecipient(recipient string) bool {
// 收件人地址必须以@mydomain.com结尾 return strings.HasSuffix(recipient, "@mydomain.com")
}
//Verify whether the sender is legitimate
func checkSender(sender string) bool {
// 任意发件人地址均合法 return true
}
//Mail structure
type Message struct {
Sender string Recipient string Subject string Body string
}
Through Golang’s SMTP library, we can easily Implement email sending and forwarding functions. When implementing SMTP email forwarding, you need to pay attention to the verification of the recipient and sender to ensure the security of the email content. In practical applications, the SMTP email forwarding function can be applied to various scenarios, such as internal email forwarding within the enterprise, message forwarding in social networks, and so on.
The above is the detailed content of How Golang implements SMTP mail forwarding function. For more information, please follow other related articles on the PHP Chinese website!
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
