Writing a SMTP Server in Go

Table of Contents

  1. Introduction
  2. Prerequisites
  3. Setting Up Go Environment
  4. Creating the SMTP Server
  5. Handling SMTP Commands
  6. Sending and Receiving Emails
  7. Testing the SMTP Server
  8. Conclusion

Introduction

In this tutorial, we will learn how to write a Simple Mail Transfer Protocol (SMTP) server using the Go programming language. SMTP is the standard protocol for email transmission over the internet, and by building our own server, we can have better control over email handling and processing. By the end of this tutorial, you will have a basic understanding of how to create an SMTP server and how to send and receive emails programmatically with Go.

Prerequisites

To follow along with this tutorial, you should have a basic understanding of Go programming language fundamentals and be familiar with concepts like functions, structs, and error handling. Additionally, you should have Go installed on your computer. If you haven’t installed Go yet, please refer to the official Go documentation for installation instructions specific to your operating system.

Setting Up Go Environment

Before we start writing our SMTP server, we need to set up a Go project and import any necessary packages. Open your terminal and follow the steps below:

  1. Create a new directory for our project: 
     mkdir smtp-server
 cd smtp-server
  2. Initialize a new Go module: 
     go mod init smtp-server
  3. Create a new Go file named main.go: 
     touch main.go
  4. Open main.go in a text editor and import the required packages: 
     package main
    
 import (
 	"fmt"
 	"log"
 	"net"
 )

Creating the SMTP Server

In this section, we will create the skeleton of our SMTP server. The server will listen on a specific port and accept incoming connections from SMTP clients.

  1. Declare a constant for the port number you want your server to listen on (e.g., 2525) and a struct to hold the server configuration: 
     const (
 	smtpPort = "2525"
 )
    
 type Server struct {
 	Address string
 }
  2. Add a Listen method to the Server struct that starts the server and accepts incoming connections: 
     func (s *Server) Listen() {
 	listener, err := net.Listen("tcp", s.Address+":"+smtpPort)
 	if err != nil {
 		log.Fatalf("Failed to start server: %v", err)
 	}
    
 	log.Printf("SMTP server listening on %s\n", s.Address+":"+smtpPort)
 	defer listener.Close()
    
 	for {
 		conn, err := listener.Accept()
 		if err != nil {
 			log.Printf("Failed to accept connection: %v\n", err)
 			continue
 		}
    
 		go s.handleConnection(conn)
 	}
 }
  3. Create a new Server instance and call the Listen method in the main function: 
     func main() {
 	server := Server{
 		Address: "localhost",
 	}
    
 	server.Listen()
 }

Handling SMTP Commands

Now that our server is listening for connections, we need to handle the commands sent by SMTP clients. In this section, we will implement the basic structure for handling SMTP commands.

  1. Create a new file named commands.go in the same directory as main.go and import the necessary packages: 
     package main
    
 import (
 	"bufio"
 	"io"
 	"log"
 	"strings"
 )
  2. Define a new method named handleConnection in the Server struct that receives the client’s connection and reads their commands: 
     func (s *Server) handleConnection(conn net.Conn) {
 	defer conn.Close()
    
 	reader := bufio.NewReader(conn)
 	writer := bufio.NewWriter(conn)
    
 	for {
 		command, err := reader.ReadString('\n')
 		if err != nil {
 			if err != io.EOF {
 				log.Printf("Failed to read command: %v\n", err)
 			}
 			return
 		}
    
 		command = strings.TrimRight(command, "\r\n")
 		s.handleCommand(conn, writer, command)
 	}
 }
  3. Implement the handleCommand method that will handle each SMTP command sent by the client: 
     func (s *Server) handleCommand(conn net.Conn, writer *bufio.Writer, command string) {
 	log.Printf("Received command: %s\n", command)
    
 	// Implement your logic for each command
 	// Example:
 	if strings.HasPrefix(command, "HELO") || strings.HasPrefix(command, "EHLO") {
 		s.handleHELO(conn, writer, command)
 	} else if command == "QUIT" {
 		s.handleQUIT(conn, writer)
 	} else {
 		s.sendResponse(writer, 500, "Command not recognized")
 	}
    
 	writer.Flush()
 }
    
 func (s *Server) handleHELO(conn net.Conn, writer *bufio.Writer, command string) {
 	// Implement HELO command logic
 }
    
 func (s *Server) handleQUIT(conn net.Conn, writer *bufio.Writer) {
 	// Implement QUIT command logic
 }
    
 func (s *Server) sendResponse(writer *bufio.Writer, code int, message string) {
 	response := fmt.Sprintf("%d %s\r\n", code, message)
 	writer.WriteString(response)
 }

Sending and Receiving Emails

Now that we can handle client commands, it’s time to implement the functionality to send and receive emails. In this section, we will handle the HELO command and send a response back to the client.

  1. Implement the handleHELO method to handle the HELO command and send a response: 
     func (s *Server) handleHELO(conn net.Conn, writer *bufio.Writer, command string) {
 	s.sendResponse(writer, 250, "Hello "+s.Address)
 }

  2. Update the handleCommand method to handle other SMTP commands such as MAIL FROM, RCPT TO, and DATA.

  3. Implement the sendEmail method that sends an email received from the client: 
     func (s *Server) sendEmail(from string, to string, data string) {
 	// Implement email sending logic
 }

Testing the SMTP Server

To test the SMTP server, we can use SMTP client libraries or command-line tools like telnet. In this section, we will use telnet to test the server.

  1. Open your terminal and run the following command to connect to the SMTP server: 
     telnet localhost 2525
  2. You can now send SMTP commands to the server. For example, try sending the HELO command: 
     HELO example.com
  3. The server should respond with a 250 code and a message. You can try other SMTP commands like MAIL FROM, RCPT TO, and DATA to test the server’s response.

Conclusion

In this tutorial, we learned how to write a basic SMTP server using Go. We covered setting up the server, handling SMTP commands, and sending and receiving emails. By following this tutorial, you now have the knowledge to build your own SMTP server or integrate SMTP functionality into your applications. Feel free to explore additional features such as authentication, error handling, and email storage to enhance your SMTP server further.

Remember that building a production-ready SMTP server requires additional considerations like security, scalability, and compliance with email standards. Please refer to the official SMTP protocol specification and best practices to ensure your server meets all requirements.

Good luck with your SMTP server development journey!

Published:

Related Articles