smtp-zig

main.zig (13091B)

---

 const std = @import("std");
 const testing = std.testing;
 
 // Library for sending email over SMTP.
 // Inspired by golang's standard lib SMTP client.
 // https://cs.opensource.google/go/go/+/master:src/net/smtp/smtp.go
 
 const log = std.log.scoped(.smtp);
 
 /// Sends an email.
 /// addr is the address of the mail server
 /// auth is authentication details for the mail server, may be null if server doesn't require auth.
 /// from is sender's email address
 /// to is list of recipient email addresses
 /// msg is the actual, interesting message.
 /// Note this library makes no effort to ensure your mail is actually a valid email, it should conform to rfc5322 otherwise servers may reject it.
 pub fn send_mail(allocator: std.mem.Allocator, server: []const u8, auth: ?Auth, from: []const u8, to: []const []const u8, msg: []const u8) !void {
     var client = try Client.init(allocator, server, auth);
     defer client.deinit();
     try client.send_mail(from, to, msg);
     try client.quit();
 }
 
 pub const Auth = struct {
     user: []const u8,
     pass: []const u8,
 };
 
 /// A Client represents a single client connection to an SMTP server.
 /// which could be used for sending many mails
 pub const Client = struct {
     const AuthCaps = struct {
         plain: bool = false,
         login: bool = false,
     };
     const Capabilities = struct {
         starttls: bool = false,
         pipelining: bool = false,
         auth: ?AuthCaps = null,
 
         fn parse(ehlo_response: []const u8) Capabilities {
             var caps = Capabilities{};
             var spl = std.mem.splitSequence(u8, ehlo_response, "\r\n");
             var nxt = spl.next(); // First line of EHLO response is just hi
             nxt = spl.next();
             while (nxt != null) : (nxt = spl.next()) {
                 if (std.mem.eql(u8, nxt.?, "STARTTLS")) {
                     caps.starttls = true;
                 } else if (std.mem.startsWith(u8, nxt.?, "AUTH")) {
                     caps.auth = AuthCaps{};
                     var spl2 = std.mem.splitScalar(u8, nxt.?, ' ');
                     var nxt2 = spl2.next();
                     nxt2 = spl2.next(); // skip the AUTH part
                     while (nxt2 != null) : (nxt2 = spl2.next()) {
                         if (std.mem.eql(u8, nxt2.?, "PLAIN")) {
                             caps.auth.?.plain = true;
                         } else if (std.mem.eql(u8, nxt2.?, "LOGIN")) {
                             caps.auth.?.login = true;
                         } else {
                             log.warn("unrecognised auth mechanism {s}", .{nxt2.?});
                         }
                     }
                 } else {
                     log.warn("unrecognised capability {s}", .{nxt.?});
                 }
             }
             return caps;
         }
     };
     const WriteError = error{} || std.net.Stream.WriteError || TlsError;
 
     fn writer(self: *Client) std.io.Writer(*Client, WriteError, write) {
         return .{
             .context = self,
         };
     }
 
     fn write(context: *Client, bytes: []const u8) WriteError!usize {
         if (context.use_tls) {
             return context.tls_stream.?.write(context.stream, bytes);
         } else {
             return context.stream.write(bytes);
         }
     }
 
     const ReadError = error{} || std.net.Stream.ReadError || TlsError;
 
     fn reader(self: *Client) std.io.Reader(*Client, ReadError, read) {
         return .{
             .context = self,
         };
     }
 
     fn read(context: *Client, buffer: []u8) ReadError!usize {
         if (context.use_tls) {
             return context.tls_stream.?.read(context.stream, buffer);
         } else {
             return context.stream.read(buffer);
         }
     }
 
     allocator: std.mem.Allocator,
     stream: std.net.Stream,
 
     capabilities: Capabilities = .{},
     use_tls: bool = false,
     tls_stream: ?std.crypto.tls.Client = null,
     tls_cert_bundle: ?std.crypto.Certificate.Bundle = null,
 
     /// Creates a new SMTP client
     /// 'server' must be "hostname:port"
     pub fn init(allocator: std.mem.Allocator, server: []const u8, maybe_auth: ?Auth) !Client {
         var spl = std.mem.splitScalar(u8, server, ':');
         const host = spl.first();
         const port_str = spl.rest();
         const port = try std.fmt.parseInt(u16, port_str, 10);
 
         const stream = try std.net.tcpConnectToHost(allocator, host, port);
         var client = Client{
             .allocator = allocator,
             .stream = stream,
         };
         errdefer client.deinit();
         allocator.free(try client.read_expect_code(220));
 
         try client.write_line("EHLO localhost");
         const ehlo_response = try client.read_expect_code(250);
         defer allocator.free(ehlo_response);
         client.capabilities = Capabilities.parse(ehlo_response);
 
         if (client.capabilities.starttls) {
             try client.write_line("STARTTLS");
             allocator.free(try client.read_expect_code(220));
 
             var bundle = std.crypto.Certificate.Bundle{};
             errdefer bundle.deinit(allocator);
             try std.crypto.Certificate.Bundle.rescan(&bundle, allocator);
             client.tls_stream = try std.crypto.tls.Client.init(stream, bundle, host);
             client.tls_cert_bundle = bundle;
             client.use_tls = true;
 
             // Redo the EHLO now we're using TLS, the capabilities might change to e.g. allow login.
             try client.write_line("EHLO localhost");
             const ehlo_response_poststarttls = try client.read_expect_code(250);
             defer allocator.free(ehlo_response_poststarttls);
             client.capabilities = Capabilities.parse(ehlo_response_poststarttls);
         }
 
         if (maybe_auth) |auth| {
             if (client.capabilities.auth) |auth_caps| {
                 if (auth_caps.plain) {
                     // TODO there has to be a nicer way than this surely
                     // TODO support identity as well as user+pass
                     const z = try std.fmt.allocPrint(allocator, "{s}\x00{s}\x00{s}", .{ "", auth.user, auth.pass });
                     defer allocator.free(z);
                     const enc = std.base64.standard.Encoder;
                     const zz = try allocator.alloc(u8, enc.calcSize(z.len));
                     defer allocator.free(zz);
                     const zzz = enc.encode(zz, z);
                     const line = try std.fmt.allocPrint(allocator, "AUTH PLAIN {s}", .{zzz});
                     defer allocator.free(line);
                     try client.write_line(line);
                     allocator.free(try client.read_expect_code(235));
                 }
             }
         }
         return client;
     }
 
     fn deinit(self: *Client) void {
         self.stream.close();
         if (self.use_tls) {
             self.tls_cert_bundle.?.deinit(self.allocator);
         }
     }
 
     /// lines in SMTP have \r\n terminator :shrug:
     /// caller owns the result
     fn read_line(self: *Client) ![]const u8 {
         var rdr = self.reader();
         var res = std.ArrayList(u8).init(self.allocator);
         var wtr = res.writer();
         while (true) {
             const b = try rdr.readByte();
             if (b == '\r') {
                 const b2 = try rdr.readByte();
                 if (b2 == '\n') {
                     break;
                 } else {
                     try wtr.writeByte(b);
                     try wtr.writeByte(b2);
                     continue;
                 }
             }
             try wtr.writeByte(b);
         }
         const res2 = try res.toOwnedSlice();
         log.debug("< {s}", .{res2});
         return res2;
     }
 
     // Reads from the stream.
     // Collects response lines (without code) into the result, which the caller owns.
     // Checks the numeric code on response lines.
     fn read_expect_code(self: *Client, expect_code: u16) ![]const u8 {
         var res = std.ArrayList(u8).init(self.allocator);
         errdefer res.deinit();
 
         while (true) {
             var line = try self.read_line();
             defer self.allocator.free(line);
             var spl = std.mem.splitAny(u8, line, " -");
             if (std.fmt.parseInt(u16, spl.first(), 10)) |code| {
                 if (code != expect_code) {
                     log.err("invalid response code {}", .{code});
                     return Client.Error.InvalidResponseCode;
                 }
             } else |_| {
                 log.err("malformatted line [{s}]", .{line});
                 return Client.Error.Malformatted;
             }
             if (line.len < 3) {
                 log.err("malformatted line [{s}]", .{line});
                 return Client.Error.Malformatted;
             }
             try res.appendSlice(line[4..]);
             // Continuation lines have "123-FOO"
             // Final line has a space like "123 BAR"
             if (line[3] == ' ') {
                 break;
             } else {
                 try res.appendSlice("\r\n");
             }
         }
         return try res.toOwnedSlice();
     }
 
     fn write_line(self: *Client, line: []const u8) !void {
         log.debug("> {s}", .{line});
         var wtr = self.writer();
         try wtr.writeAll(line);
         try wtr.writeAll("\r\n");
     }
 
     pub fn mail(self: *Client, from: []const u8) !void {
         const line = try std.fmt.allocPrint(self.allocator, "MAIL FROM:<{s}>", .{from});
         defer self.allocator.free(line);
         try self.write_line(line);
         const r = try self.read_expect_code(250);
         self.allocator.free(r);
     }
 
     pub fn rcpt(self: *Client, to: []const u8) !void {
         const line = try std.fmt.allocPrint(self.allocator, "RCPT TO:<{s}>", .{to});
         defer self.allocator.free(line);
         try self.write_line(line);
         const r = try self.read_expect_code(250);
         self.allocator.free(r);
     }
 
     pub fn data(self: *Client, rdr: anytype) !void {
         try self.write_line("DATA");
         self.allocator.free(try self.read_expect_code(354));
         var buf: [1024]u8 = undefined;
         var r = try rdr.read(&buf);
         while (r > 0) : (r = try rdr.read(&buf)) {
             // TODO proper dot encoding, ensure any existing sequences of \r\n.\r\n are escaped I guess
             log.debug("> {s}", .{buf[0..r]});
             try self.writer().writeAll(buf[0..r]);
         }
         try self.write_line("\r\n.");
         self.allocator.free(try self.read_expect_code(250));
     }
 
     pub fn rset(self: *Client) !void {
         try self.write_line("RSET");
         self.allocator.free(try self.read_expect_code(250));
     }
 
     pub fn quit(self: *Client) !void {
         try self.write_line("QUIT");
         self.allocator.free(try self.read_expect_code(221));
     }
 
     pub fn send_mail(self: *Client, from: []const u8, to: []const []const u8, msg: []const u8) !void {
         try self.rset();
         try self.mail(from);
         for (to) |t| {
             try self.rcpt(t);
         }
         var fbs = std.io.fixedBufferStream(msg);
         try self.data(fbs.reader());
     }
 
     const Error = error{ Malformatted, InvalidResponseCode };
 };
 
 // TODO why doesn't tls module define an error set?
 const TlsError = error{
     Overflow,
     TlsAlertUnexpectedMessage,
     TlsAlertBadRecordMac,
     TlsAlertRecordOverflow,
     TlsAlertHandshakeFailure,
     TlsAlertBadCertificate,
     TlsAlertUnsupportedCertificate,
     TlsAlertCertificateRevoked,
     TlsAlertCertificateExpired,
     TlsAlertCertificateUnknown,
     TlsAlertIllegalParameter,
     TlsAlertUnknownCa,
     TlsAlertAccessDenied,
     TlsAlertDecodeError,
     TlsAlertDecryptError,
     TlsAlertProtocolVersion,
     TlsAlertInsufficientSecurity,
     TlsAlertInternalError,
     TlsAlertInappropriateFallback,
     TlsAlertMissingExtension,
     TlsAlertUnsupportedExtension,
     TlsAlertUnrecognizedName,
     TlsAlertBadCertificateStatusResponse,
     TlsAlertUnknownPskIdentity,
     TlsAlertCertificateRequired,
     TlsAlertNoApplicationProtocol,
     TlsAlertUnknown,
     TlsUnexpectedMessage,
     TlsIllegalParameter,
     TlsRecordOverflow,
     TlsBadRecordMac,
     TlsConnectionTruncated,
     TlsDecodeError,
     TlsBadLength,
 };
 
 test "send email" {
     const mail =
         \\Subject: test
         \\From: <martin@mfashby.net>
         \\To: <martin@mfashby.net>
         \\
         \\This is a test message
     ;
     const user = std.posix.getenv("SMTP_USERNAME").?;
     const pass = std.posix.getenv("SMTP_PASSWORD").?;
     var client = try Client.init(std.testing.allocator, "mail.mfashby.net:587", .{ .user = user, .pass = pass });
     defer client.deinit();
     try client.send_mail("martin@mfashby.net", &[_][]const u8{"martin@mfashby.net"}, mail);
     const mail2 =
         \\Subject: test2
         \\From: <martin@mfashby.net>
         \\To: <martin@mfashby.net>
         \\
         \\This is another test message
     ;
     try client.send_mail("martin@mfashby.net", &[_][]const u8{"martin@mfashby.net"}, mail2);
     try client.quit(); // Be nice (but we don't have to)
 }
 
 // TODO lots more tests.
 // TODO use mock SMTP server to integration test local only.