How Golang implements SMTP mail forwarding function

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.

1. SMTP Introduction

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:

• Mail sender: The user or system that needs to send mail.
• Mail recipient: The user or system that needs to receive mail.
• SMTP client: An application used to send emails.
• SMTP server: Server used to receive and forward emails.

The SMTP protocol workflow is as follows:

• The client connects to the SMTP server.
• The client sends the EHLO command to the server to negotiate communication parameters.
• The client sends authentication information to the server.
• The client sends email information and recipient information to the server.
• The server finds and connects to the receiving server based on the recipient information.
• Send email information and recipient information to the receiving server.
• The receiving server stores the email in the corresponding mailbox.

2. Usage of SMTP library

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

3. Implementation of mail forwarding function

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:

• Listen to the port number in the project and accept incoming emails.
• Determine whether the recipient and sender meet the requirements. If it matches, the email content is encapsulated into Mail type and sent to the forwarding service address.
• Receive the response from the forwarding service and determine whether the email is successfully forwarded.

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

}

4. Conclusion

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!