Email (SMTP / IMAP / POP3)

import stdlib::mail::message::*;   // Mail, Attachment, parse_mail
import stdlib::mail::smtp::*;      // SmtpClient, SmtpSession, SmtpReply
import stdlib::mail::imap::*;      // ImapSession, ImapResponse
import stdlib::mail::pop3::*;      // Pop3Session, Pop3MsgInfo

pub struct Attachment {
    pub filename:  string,
    pub mime_type: string,
    pub data:      string,
}

import stdlib::mail::message::*;

fn main() -> i32 {
    let att: *Attachment = malloc(sizeof(Attachment)) as *Attachment;
    att.filename = "report.csv";
    att.mime_type = "text/csv";
    att.data = "a,b\n1,2";

    let m: *Mail = Mail::new();
    m.from = "[email protected]";
    m.to.push("[email protected]");
    m.subject = "report";
    m.body = "see attached";
    m.attachments.push(att);

    let wire: string = m.to_rfc5322();        // multipart/mixed
    println!("len", wire.len());
    println!("has base64:", wire.contains("base64"));
    return 0;
}

pub struct Mail {
    pub from:        string,
    pub to:          *Vector<string>,
    pub cc:          *Vector<string>,
    pub bcc:         *Vector<string>,
    pub subject:     string,
    pub body:        string,             // plain-text body
    pub html:        ?string,            // optional HTML alternative
    pub attachments: *Vector<*Attachment>,
    pub headers:     *HashMap<string>,   // extra headers (Reply-To, etc.)
    pub date:        string,             // empty = auto-fill at to_rfc5322
    pub message_id:  string,             // empty = auto-fill
}

pub fn new() -> *Mail

pub fn to_rfc5322(self: *Mail) -> string

import stdlib::mail::message::*;

fn main() -> i32 {
    let m: *Mail = Mail::new();
    m.from = "[email protected]";
    m.to.push("[email protected]");
    m.cc.push("[email protected]");
    m.subject = "hello";
    m.body = "Plain text body.";
    m.html = some("<p>HTML body.</p>");

    let att: *Attachment = malloc(sizeof(Attachment)) as *Attachment;
    att.filename = "doc.txt";
    att.mime_type = "text/plain";
    att.data = "x";
    m.attachments.push(att);

    m.headers.insert("Reply-To", "[email protected]");

    let wire: string = m.to_rfc5322();   // multipart/mixed { alternative, attachment }
    println!("wire bytes:", wire.len());
    return 0;
}

import stdlib::mail::message::*;

fn main() -> i32 {
    let m: *Mail = Mail::new();
    m.from = "[email protected]";
    m.to.push("[email protected]");
    m.subject = "cafe";
    m.body = "caf\u{00e9}";              // non-ASCII -> quoted-printable
    m.headers.insert("Reply-To", "[email protected]");

    let w1: string = m.to_rfc5322();
    println!("auto date:", w1.contains("Date: "));
    println!("auto msgid:", w1.contains("Message-Id: <"));
    println!("qp encoding:", w1.contains("quoted-printable"));

    m.date = "Tue, 01 Jan 2026 00:00:00 +0000";
    m.message_id = "[email protected]";
    let w2: string = m.to_rfc5322();
    println!("explicit msgid:", w2.contains("Message-Id: <[email protected]>"));
    return 0;
}

pub fn parse_mail(raw: string) -> !*Mail

import stdlib::mail::message::*;

fn main() -> !i32 {
    let raw: string = "From: [email protected]\r\nTo: [email protected], [email protected]\r\nSubject: hi\r\nMessage-Id: <abc@x>\r\nX-Custom: yes\r\n\r\nbody here";
    let m: *Mail = parse_mail(raw)?;
    println!("from:", m.from);
    println!("subject:", m.subject);
    println!("message-id:", m.message_id);   // "abc@x" — brackets stripped
    println!("to count:", m.to.len());        // 2 — comma-split
    println!("custom:", m.headers.get("X-Custom"));
    println!("body:", m.body);

    // Missing blank-line separator → error.
    let bad: !*Mail = parse_mail("From: x\r\nno blank line");
    println!("err surfaces:", !bad.ok);
    return ok(0);
}

pub struct SmtpClient {
    pub host:         string,
    pub port:         i32,
    pub use_tls:      bool,     // implicit TLS from byte one (port 465 / SMTPS)
    pub use_starttls: bool,     // STARTTLS upgrade after EHLO (port 587)
    pub username:     ?string,
    pub password:     ?string,
    pub timeout_ms:   i32,
    pub tls_insecure: bool,     // skip cert validation — local dev only
    pub auth_method:  string,   // "auto" | "plain" | "login"
}

pub fn new(host: string, port: i32) -> *SmtpClient

pub fn send(self: *SmtpClient, mail: *Mail) -> !i32

import stdlib::mail::message::*;
import stdlib::mail::smtp::*;

fn main() -> i32 {
    let c: *SmtpClient = SmtpClient::new("smtp.example.com", 587);
    c.use_starttls = true;
    c.username = some("alice");
    c.password = some("hunter2");
    c.timeout_ms = 10000;
    c.auth_method = "auto";

    let m: *Mail = Mail::new();
    m.from = "[email protected]";
    m.to.push("[email protected]");
    m.bcc.push("[email protected]");   // delivered, but hidden from headers
    m.subject = "ping";
    m.body = "hi";

    let r: !i32 = c.send(m);
    if !r.ok { println!(r.err); return 1; }
    return 0;
}

import stdlib::mail::message::*;
import stdlib::mail::smtp::*;

fn main() -> i32 {
    let c: *SmtpClient = SmtpClient::new("localhost", 587);
    c.use_starttls = true;
    c.tls_insecure = true;        // skip cert validation — dev only
    c.auth_method = "login";      // force AUTH LOGIN
    c.username = some("dev");
    c.password = some("dev");

    let m: *Mail = Mail::new();
    m.from = "dev@localhost";
    m.to.push("inbox@localhost");
    m.subject = "test";
    m.body = "x";

    let r: !i32 = c.send(m);
    if !r.ok { println!(r.err); return 1; }
    return 0;
}

pub fn connect(self: *SmtpClient) -> !*SmtpSession

pub struct SmtpReply {
    pub code: i32,      // numeric status (e.g. 250, 354, 535)
    pub text: string,   // last reply line (multi-line replies collapse to the final line)
}

pub struct SmtpSession {
    pub host:       string,
    // tcp / tls / is_tls are private transport state
    pub auth_mechs: string,   // mechanisms the server advertised at EHLO, lowercased
}

pub fn send_mail(self: *SmtpSession, mail: *Mail) -> !i32

pub fn quit(self: *SmtpSession) -> !i32
pub fn close(self: *SmtpSession)

import stdlib::mail::message::*;
import stdlib::mail::smtp::*;

fn build(i: i32) -> *Mail {
    let m: *Mail = Mail::new();
    m.from = "[email protected]";
    m.to.push("[email protected]");
    m.subject = "msg";
    m.body = "hello";
    return m;
}

fn main() -> i32 {
    let c: *SmtpClient = SmtpClient::new("smtp.example.com", 465);
    c.use_tls = true;

    let r: !*SmtpSession = c.connect();
    if !r.ok { println!(r.err); return 1; }
    let s: *SmtpSession = r.val;
    println!("host:", s.host);
    println!("advertised:", s.auth_mechs);

    for let i: i32 = 0; i < 3; i++ {
        let m: *Mail = build(i);
        let sr: !i32 = s.send_mail(m);
        if !sr.ok { println!(sr.err); }
    }
    let _q: !i32 = s.quit();
    s.close();
    return 0;
}

pub struct ImapSession {
    pub host: string,
    // tcp / tls / is_tls / rx_buf / tag_counter / idle_tag are private state
}

pub struct ImapResponse {
    pub untagged: *Vector<string>,   // every "* ..." line for the command
    pub tagged:   string,            // the final tagged line ("A3 OK ...")
    pub literal:  string,            // captured {N} literal payload (e.g. FETCH body)
}

import stdlib::mail::message::*;
import stdlib::mail::imap::*;

fn main() -> i32 {
    let r: !*ImapSession = ImapSession::connect("imap.example.com", 993, true);
    if !r.ok { println!(r.err); return 1; }
    let p: *ImapSession = r.val;
    println!("host:", p.host);

    let lr: !i32 = p.login("[email protected]", "app-password");
    if !lr.ok { println!(lr.err); p.close(); return 1; }

    let count: !i32 = p.select("INBOX");
    if count.ok && count.val > 0 {
        let raw: !string = p.fetch(1);
        if raw.ok {
            let m: !*Mail = parse_mail(raw.val);
            if m.ok { println!("subject:", m.val.subject); }
        }
        let _f: !i32 = p.store_flag(1, "\\Seen", true);   // mark as read
    }

    let un: !*Vector<i32> = p.search_unseen();
    if un.ok { println!("unread:", un.val.len()); }

    let fr: !*Vector<i32> = p.search_from("[email protected]");
    if fr.ok { println!("from alice:", fr.val.len()); }

    let hits: !*Vector<i32> = p.search("UNSEEN SUBJECT \"alert\"");
    if hits.ok {
        for let i: i32 = 0; i < hits.val.len(); i++ {
            println!("msg #", hits.val.get(i));
        }
    }

    let _lo: !i32 = p.logout();
    p.close();
    return 0;
}

import stdlib::mail::message::*;
import stdlib::mail::imap::*;

fn main() -> i32 {
    let r: !*ImapSession = ImapSession::connect("imap.example.com", 993, true);
    if !r.ok { println!(r.err); return 1; }
    let p: *ImapSession = r.val;
    let _l: !i32 = p.login("[email protected]", "pw");

    // APPEND a draft into the Drafts mailbox.
    let m: *Mail = Mail::new();
    m.from = "[email protected]";
    m.to.push("[email protected]");
    m.subject = "draft";
    m.body = "WIP";
    let _a: !i32 = p.append("Drafts", "\\Seen", m.to_rfc5322());

    // Wait for new mail, then return to command mode.
    let _is: !i32 = p.idle_start();
    while true {
        let line: !string = p.idle_next();
        if !line.ok { break; }
        if line.val.contains("EXISTS") { break; }   // new mail arrived
    }
    let _ie: !i32 = p.idle_stop();

    let _lo: !i32 = p.logout();
    p.close();
    return 0;
}

pub struct Pop3MsgInfo {
    pub idx:  i32,
    pub size: i32,
}

pub struct Pop3Session {
    pub host: string,
    // tcp / tls / is_tls / rx_buf are private transport state
}

import stdlib::mail::message::*;
import stdlib::mail::pop3::*;

fn main() -> i32 {
    let r: !*Pop3Session = Pop3Session::connect("pop.example.com", 995, true);
    if !r.ok { println!(r.err); return 1; }
    let p: *Pop3Session = r.val;
    println!("host:", p.host);

    let _l: !i32 = p.login("[email protected]", "app-password");

    let st: !*Pop3MsgInfo = p.stat();
    if st.ok { println!(st.val.idx, "msgs,", st.val.size, "bytes"); }

    let lst: !*Vector<*Pop3MsgInfo> = p.list();
    if lst.ok {
        for let i: i32 = 0; i < lst.val.len(); i++ {
            let info: *Pop3MsgInfo = lst.val.get(i);
            println!("#", info.idx, "size", info.size);
            let raw: !string = p.retrieve(info.idx);
            if raw.ok {
                let m: !*Mail = parse_mail(raw.val);
                if m.ok { println!("subject:", m.val.subject); }
            }
        }
    }

    let _d: !i32 = p.delete(1);   // committed at quit
    let _n: !i32 = p.noop();
    let _q: !i32 = p.quit();
    p.close();
    return 0;
}