%%%------------------------------------------------------------------------
%%% @doc SMTP mail client.  This module can sent emails to one or more
%%%      recipients, using primary/backup SMTP servers.  Messages can
%%%      contain attachments.
%%%
%%% ```
%%% Example:
%%%     % Send a message to two recipients with a file attachment using
%%%     % SSL protocol at mail server "mail.bevemyr.com":
%%%     smtp:send(ssl, "Alex <jb@bevemyr.com>",
%%%               ["katrin@bevemyr.com","jb@bevemyr.com"],
%%%               "Test Subject", "My Message",
%%%               [{server, "mail.bevemyr.com"},
%%%                {username, "alex"}, {password, "secret"},
%%%                {attachments, ["file1.txt"]}]).
%%%
%%%     % Send a message to a recipient with a file attachment given custom
%%%     % MIME type using localhost mail server
%%%     smtp:send(tcp, "jb@bevemyr.com",
%%%               ["katrin@bevemyr.com"], "Test Subject", "My Message",
%%%               [{server, "mail.bevemyr.com"},
%%%                {username, "alex"}, {password, "secret"},
%%%                {attachments, [{"file1.bin","application/custom_MIME"}]}]).
%%%
%%%     % Send a message to two recipients with an attachment given as list
%%%     smtp:send(tcp, "jb@bevemyr.com",
%%%               ["katrin@bevemyr.com","jb@bevemyr.com"],
%%%               "Test Subject", "My Message",
%%%               [{"file1.txt","text/plain","Attachment past as list"}]).
%%% '''
%%%
%%% @author  Johan Bevemyr, Serge Aleynikov <saleyn@gmail.com>
%%% @end
%%%------------------------------------------------------------------------
%%% Created 02/24/2004 Johan Bevemyr
%%%------------------------------------------------------------------------
-module(smtp).
-author('jb@son.bevemyr.com').
-author('saleyn@gmail.com').

-export([send/5, send/6, domain/0]).

-include_lib("kernel/include/inet.hrl").

-type proto() :: tcp | ssl.
%% Protocol type.

-type smtp_options() :: [
          {server, Server::string()}
        | {relay, Relay::string()}
        | {port, Port::integer()}
        | {auth, Auth :: always | never}
        | {username, Username::string()}
        | {password, Password::string()}
        | {tls, Tls :: always | if_available}
        | {domain, Domain::string()}
        | {timeout, Millisec::integer()}
        | {verbose, debug}
        | {ssl, SSLOpts::list()}
        | {attachments, [
             Filename::string() |
             {Filename::string(), ContentType::string()} |
             {Filename::string(), ContentType::string(), Data::list()}]}].
%% SNMP Options
%%     <ul>
%%      <li>Server - server to connect to (no MX lookup)</li>
%%      <li>Relay  - domain to do MX lookup of list of servers</li>
%%      <li>Port   - optional port number (ssl def: 465; tcp def: 25)</li>
%%      <li>Auth   - controls mandatory / optional authentication</li>
%%      <li>Tls    - controls enabling of TLS protocol</li>
%%      <li>Domain - name of the domain to include in the HELO handshake</li>
%%      <li>Timeout - timeout to use (default 10000)</li>
%%      <li>Verbose - controls debugging printout</li>
%%      <li>Attachments - list of files to attach</li>
%%      <li>SSLOpts - additional SSL options if using SSL protocol</li>
%%     </ul>

%%-------------------------------------------------------------------------
%% @doc Send a message to a list of `To' receipients using `localhost'.
%%      Error is thrown if unable to send a message.
%%      Use inet:format_error/1 to decode the Reason if it is an atom.
%% @end
%%-------------------------------------------------------------------------
-spec send(Proto :: proto(), From :: string() | binary(),
            To :: string() | binary(), Subj :: string() | binary(),
            Msg :: string() | binary()) -> ok.
send(Proto, From, To, Subject, Message) ->
    send(Proto, From, To, Subject, Message, []).

%%-------------------------------------------------------------------------
%% @doc Send a message to a list of recipients by connecting to an SMTP
%%      server Server.  The message can contain attachments in the
%%      Attachments list.  See examples on the top of this page.
%%      Error is thrown if unable to send a message.
%% @end
%%-------------------------------------------------------------------------
-spec send(Proto :: proto(), From :: string() | binary(),
            To :: string() | binary(), Subj :: string() | binary(),
            Msg :: string() | binary(), Opts :: smtp_options()) -> ok.
send(Proto, From, To, Subj, Msg, Opts)
  when Proto =:= tcp; Proto =:= ssl ->
    Module = proto_module(Proto),
    case proplists:get_value(server, Opts) of
    undefined ->
        case proplists:get_value(relay, Opts) of
        undefined ->
            try_send(Module, From, To, Subj, Msg, "localhost", Opts);
        Domain ->
            Servers = mxlookup(Domain),
            send_mail(Module, Servers, {From, To, Subj, Msg},
                no_servers_provided, Opts)
        end;
    [I | _] = Server when is_integer(I) ->
        try_send(Module, From, To, Subj, Msg, Server, Opts);
    Servers when is_list(Servers) ->
        send_mail(Module, Servers, {From, To, Subj, Msg},
            no_servers_provided, Opts)
    end.


%%-------------------------------------------------------------------------
%% @doc Get domain that this host belongs to.
%% @end
%%-------------------------------------------------------------------------
-spec domain() -> binary().
domain() ->
    case lists:keyfind(domain, 1, inet:get_rc()) of
    {domain, D} when is_binary(D) -> D;
    {domain, D} when is_list(D)   -> list_to_binary(D);
    false -> 
        {ok, Hostname} = inet:gethostname(),
        {ok, #hostent{h_name = FQDN}} = inet:gethostbyname(Hostname),
        list_to_binary(FQDN)
    end.

%%%------------------------------------------------------------------------
%%% Internal functions
%%%------------------------------------------------------------------------

proto_module(tcp) -> gen_tcp;
proto_module(ssl) -> ssl.

mxlookup(Domain) ->
    case whereis(inet_db) of
    P when is_pid(P)    -> ok;
    _                   -> inet_db:start()
    end,
    case lists:keyfind(nameserver, 1, inet_db:get_rc()) of
    false ->
        % we got no nameservers configured, suck in resolv.conf
        inet_config:do_load_resolv(os:type(), longnames);
    _ ->
        ok
    end,
    case inet_res:lookup(Domain, in, mx) of
    [] -> [];
    L  -> [H || {_, H} <- lists:sort(L)]
    end.

try_send(Module, From, To, Subj, Msg, Server, Opts) ->
    Verbose = proplists:get_value(verbose, Opts),
    Attachments = proplists:get_value(attachments, Opts, []),
    Port = smtp_init(Module, Server, From, To, Verbose, Opts),
    Boundary=boundary_bin(Attachments),
    smtp_send_headers(Module, Port, From, To, Subj, Boundary),
    smtp_send_message(Module, Port, Msg, Boundary),
    smtp_send_attachments(Module, Port, Attachments, Boundary),
    smtp_close(Module, Port).

send_mail(_Mod, [], _What, LastReason, _Options) ->
    throw(LastReason);
send_mail(Mod, [S | Rest], {From, To, Subj, Msg} = What, _LastReason, Options) ->
    try
        ok = try_send(Mod, From, To, Subj, Msg, S, Options)
    catch
        _:Reason when is_atom(Reason) ->
            % This is likely a connection error
            send_mail(Mod, Rest, What, Reason, Options);
        C:R:Stack ->
            % This is the case when a server couldn't send the message due to
            % other than networking reasons.  Don't retry.
            erlang:raise(C,R,Stack)
    end.

smtp_send_headers(Mod, Port, From, To, Subject, Boundary) ->
    CommonHeaders = [mail_headers(<<"To: ">>,      [list_to_binary(T) || T <- To]),
                     mail_header (<<"From: ">>,    list_to_binary(From)),
                     mail_header (<<"Subject: ">>, list_to_binary(Subject))],
    Headers =
        case Boundary of
        undefined ->
            [mail_header(<<"Content-Type: ">>, <<"text/plain">>),
             mail_header(<<"Content-Transfer-Encoding: ">>, <<"8bit">>)];
        _ ->
            [mail_header(<<"Mime-Version: ">>, <<"1.0">>),
             mail_header(<<"Content-Type: ">>, [<<"Multipart/Mixed; boundary=\"">>,
                                                Boundary, <<"\"">>]),
             mail_header(<<"Content-Transfer-Encoding: ">>, <<"8bit">>)]
        end,
    Mod:send(Port, [CommonHeaders, Headers, <<"\r\n">>]).

smtp_send_message(Mod, Port, Data, Boundary) ->
    case Boundary of
    undefined ->
        ok;
    _ ->
        Mod:send(Port,
                 [<<"--">>,Boundary,<<"\r\n">>,
                  mail_header(<<"Content-Type: ">>, <<"Text/Plain; charset=us-ascii">>),
                  mail_header(<<"Content-Transfer-Encoding: ">>, <<"8bit">>),
                  <<"\r\n">>])
    end,
    {_LastNL, Escaped} = dot_escape(Data, true),
    Mod:send(Port, Escaped).

smtp_send_attachments(Mod, Port, [], _Boundary) ->
    Mod:send(Port, <<"\r\n.\r\n">>);
smtp_send_attachments(Mod, Port, Attachments, Boundary) ->
    send_attachments(Mod, Port, Boundary, Attachments),
    Mod:send(Port, <<"\r\n.\r\n">>).

send_attachments(Mod, Port, Boundary, []) ->
    Mod:send(Port, <<"\r\n--",(list_to_binary(Boundary))/binary,"--\r\n">>);

send_attachments(Mod, Port, Boundary, [{FileName,ContentType}|Rest]) ->
    Data =
        case file:read_file(FileName) of
        {ok, Bin} ->
            binary_to_list(Bin);
        {error, Reason} ->
            throw(lists:flatten(
                io_lib:format("File ~s: ~s", [FileName, file:format_error(Reason)])))
        end,
    send_attachment(Mod, Port, Boundary, FileName, ContentType, Data),
    send_attachments(Mod, Port, Boundary, Rest);

send_attachments(Mod, Port, Boundary, [{FileName,ContentType,Data}|Rest]) ->
    send_attachment(Mod, Port, Boundary, FileName, ContentType, Data),
    send_attachments(Mod, Port, Boundary, Rest);

send_attachments(Mod, Port, Boundary, [FileName | Rest]) ->
    send_attachments(Mod, Port, Boundary, [{FileName, undefined} | Rest]).

send_attachment(Mod, Port, Boundary, FileName, ContentType, Data) ->
    File = filename:basename(FileName,""),
    CT = case {ContentType, io_lib:printable_list(Data)} of
         {undefined, true}  -> "plain/text";
         {undefined, false} -> "application/octet-stream; name=\"" ++ File ++"\"";
         {_, _}             -> ContentType
         end,
    Mod:send(Port,
             [<<"\r\n--">>,Boundary,<<"\r\n">>,
              mail_header(<<"Content-Type: ">>, CT),
              mail_header(<<"Content-Transfer-Encoding: ">>, <<"base64">>),
              mail_header(<<"Content-Disposition: ">>,
                          [<<"attachment; filename=\"">>, list_to_binary(File), <<"\"">>]),
              <<"\r\n">>
             ]),
    B64 = sting2base64(Data),
    Mod:send(Port, B64).

def_port_and_opts(gen_tcp, _Opts) ->
    {25, [{active, false}, {reuseaddr,true}, {packet, line}, binary]};
def_port_and_opts(ssl, Opts) ->
    SSLOpts = proplists:get_value(ssl, Opts, []),
    {465, SSLOpts ++ [{active, false}, {depth, 3}, {packet, line}, {ssl_imp, new}, binary]}.

connect(gen_tcp, Server, _Verbose, _Options) when is_port(Server) ->
    Server;
connect(Mod, Server, Verbose, Options) ->
    {DefPort, SockOpts} = def_port_and_opts(Mod, Options),
    Timeout             = proplists:get_value(timeout, Options, 10000),
    % For ssl make sure applications crypto, public_key and ssl are started
    if is_port(Server) ->
        case Mod:connect(Server, SockOpts, Timeout) of
        {ok, Sock}   -> Sock;
        {error, Why} -> throw(Why)
        end;
    true ->
        Port = proplists:get_value(port, Options, DefPort),
        print(Verbose, "Connecting to: ~w://~s:~w\n", [Mod, Server, Port]),
        case Mod:connect(Server, Port, SockOpts, Timeout) of
        {ok,   Sock} -> Sock;
        {error, Why} -> throw(Why)
        end
    end.

domain(Options) ->
    case proplists:get_value(domain, Options) of
    undefined ->
        domain();
    Domain when is_binary(Domain) ->
        Domain;
    Domain when is_list(Domain) ->
        list_to_binary(Domain)
    end.

smtp_STARTTLS(ssl, Port, _Options, Extensions, _Domain, _Verbose) ->
    {Port, Extensions};
smtp_STARTTLS(Mod, Port, Options, Extensions, Domain, Verbose) ->
    case {proplists:get_value(tls, Options), proplists:get_value(<<"STARTTLS">>, Extensions)} of
    {always, true} ->
        do_STARTTLS(Mod, Port, Extensions, Verbose, Options, Domain);
    {if_available, true} ->
        do_STARTTLS(Mod, Port, Extensions, Verbose, Options, Domain);
    {always, _} ->
        smtp_close(Mod, Port),
        throw({missing_requirement, tls});
    _ ->
        {Port, Extensions}
    end.

do_STARTTLS(Mod, Port, Extensions, Verbose, Options, Domain) ->
    smtp_put(Mod, <<"STARTTLS">>, Port),
    smtp_expect(Mod, <<"220">>, Port, undefined),
    case Mod of
    ssl ->
        {Port, Extensions};
    gen_tcp ->
        Sock = connect(ssl, Port, Verbose, Options),
        {ok, Extensions2} = try_HELO(Mod, Port, Domain),
        {Sock, Extensions2}
    end.

try_AUTH(Mod, Port, Options, Ext, _Verbose) when Ext =:= undefined; Ext =:= [] ->
    case proplists:get_value(auth, Options) of
    always ->
        smtp_close(Mod, Port),
        throw({missing_requirement, auth});
    _ ->
        {false, proplists:get_value(username, Options)}
    end;
try_AUTH(Mod, Port, Options, AuthTypes, Verbose) ->
    Username = proplists:get_value(username, Options),
    Password = proplists:get_value(password, Options),
    Auth     = proplists:get_value(auth,     Options),
    case Auth of
    never ->
        {false, Username};
    _ when Username =:= undefined ->
        throw({missing_auth, username});
    _ when Password =:= undefined ->
        throw({missing_auth, password});
    _ ->
        Types = [decode_auth(X) || X <- re:split(AuthTypes, " ", [{return, binary}, trim])],
        AllowedTypes = [X || X <- Types, is_atom(X)],
        case do_AUTH_each(Mod, Port, Username, Password, AllowedTypes, Verbose) of
        false when Auth =:= always ->
            smtp_close(Mod, Port),
            erlang:throw({permanent_failure, auth_failed});
        false ->
            {false, Username};
        true ->
            {true, Username}
        end
    end.

decode_auth(<<"CRAM-MD5">>) -> cram_md5;
decode_auth(<<"cram-md5">>) -> cram_md5;
decode_auth(<<"LOGIN">>)    -> login;
decode_auth(<<"login">>)    -> login;
decode_auth(<<"PLAIN">>)    -> plain;
decode_auth(<<"plain">>)    -> plain;
decode_auth(Other)          -> Other.

to_hex(Prefix, Bin) -> list_to_binary(Prefix ++ [to_hex_int(I) || <<I>> <= Bin]).
to_hex_int(I) when I < 10  -> $0 + I;
to_hex_int(I) when I < 16  -> $A + (I - 10);
to_hex_int(I) when I < 256 -> J = I div 256, [to_hex_int(J), to_hex_int(I - 256*J)].

do_AUTH_each(_Mod, _Port, _Username, _Password, [], _Verbose) ->
    false;
do_AUTH_each(Mod, Port, Username, Password, [cram_md5 | Tail], Verbose) ->
    smtp_put(Mod, <<"AUTH CRAM-MD5">>, Port),
    try
        {ok, Seed64} = smtp_expect(Mod, <<"334">>, Port, undefined),
        Seed = base64:decode_to_string(Seed64),
        Bin  = crypto:mac(hmac, md5, Password, Seed),
        Digest = to_hex([Username, " "], Bin),
        smtp_put(Mod, base64:encode(Digest), Port),
        smtp_expect(Mod, <<"235">>, Port, undefined),
        print(Verbose, "Authenticated using crom_md5\n", []),
        true
    catch _:_ ->
        do_AUTH_each(Mod, Port, Username, Password, Tail, Verbose)
    end;
do_AUTH_each(Mod, Port, Username, Password, [login | Tail], Verbose) ->
    smtp_put(Mod, <<"AUTH LOGIN">>, Port),
    try
        {ok, <<"VXNlcm5hbWU6", _/binary>>} = smtp_expect(Mod, <<"334">>, Port, undefined),
        U = base64:encode(Username),
        smtp_put(Mod, U, Port),
        {ok, <<"UGFzc3dvcmQ6", _/binary>>} = smtp_expect(Mod, <<"334">>, Port, undefined),
        P = base64:encode(Password),
        smtp_put(Mod, P, Port),
        smtp_expect(Mod, <<"235">>, Port, undefined),
        print(Verbose, "Authenticated using login\n", []),
        true
    catch _:_ ->
        do_AUTH_each(Mod, Port, Username, Password, Tail, Verbose)
    end;
do_AUTH_each(Mod, Port, Username, Password, [plain | Tail], Verbose) ->
    AuthString = base64:encode("\0"++Username++"\0"++Password),
    smtp_put(Mod, [<<"AUTH PLAIN ">>, AuthString], Port),
    try
        smtp_expect(Mod, <<"235">>, Port, undefined),
        print(Verbose, "Authenticated using plain\n", []),
        true
    catch _:_ ->
        do_AUTH_each(Mod, Port, Username, Password, Tail, Verbose)
    end.

try_HELO(Mod, Port, Domain) ->
    smtp_put(Mod, [<<"EHLO ">>, Domain], Port),
    try
        smtp_expect(Mod, <<"250">>, Port, undefined)
    catch throw:<<"500", _/binary>> ->
        smtp_put(Mod, [<<"HELO ">>, Domain], Port),
        smtp_expect(Mod, <<"250">>, Port, undefined)
    end.

smtp_init(Mod, Server, From, Recipients, Verbose, Options) ->
    Port = connect(Mod, Server, Verbose, Options),
    smtp_expect(Mod, <<"220">>, Port, "SMTP server does not respond"),
    Domain = domain(Options),
    {ok, Extensions} = try_HELO(Mod, Port, Domain),
    print(Verbose, "Extensions: ~p\n", [Extensions]),
    {Port2, Extensions2} = smtp_STARTTLS(Mod, Port, Options, Extensions, Domain, Verbose),
    {_Auth, Username} =
        try_AUTH(Mod, Port, Options, proplists:get_value(<<"AUTH">>, Extensions2), Verbose),
    FromEmail = format_email(Username, From),
    print(Verbose, "From email: ~p\n", [FromEmail]),
    smtp_put(Mod, [<<"MAIL FROM: ">>, FromEmail], Port2),
    smtp_expect(Mod, <<"250">>, Port2, undefined),
    send_recipients(Mod, Recipients, Port2),
    smtp_put(Mod, <<"DATA">>, Port2),
    smtp_expect(Mod, <<"354">>, Port2, "Message not accepted by mail server."),
    Port2.

smtp_close(Mod, Port) ->
    smtp_put(Mod, <<".">>, Port),
    smtp_expect(Mod, <<"250">>, Port, "Message not accepted by mail server."),
    Mod:close(Port),
    ok.

format_email(undefined, Default) -> format_email(Default);
format_email(Other, _Default)    -> format_email(Other).

format_email(Addr) when is_list(Addr) ->
    case lists:splitwith(fun(I) -> I =/= $< end, Addr) of
    {_, []} -> [list_to_binary([$< | Addr]), $>];
    {_, A}  -> list_to_binary(A)
    end;
format_email(Addr) when is_binary(Addr) ->
    case binary:match(Addr, <<"<">>) of
    {0, _}  -> Addr;
    {I, _}  -> binary:part(Addr, {I, byte_size(Addr) - I});
    nomatch -> [$<, Addr, $>]
    end.

send_recipients(Mod, To, Port) when is_binary(To) ->
    send_recipients2(Mod, [<<"RCPT TO: ">>, format_email(To)], Port);
send_recipients(Mod, [R|_] = Addr, Port) when is_integer(R) ->
    send_recipients2(Mod, [<<"RCPT TO: ">>, format_email(Addr)], Port);
send_recipients(Mod, List, Port) when is_list(List) ->
    [send_recipients2(Mod, [<<"RCPT TO: ">>, format_email(A)], Port) || A <- List],
    ok.

send_recipients2(Mod, Data, Port) ->
    smtp_put(Mod, Data, Port),
    smtp_expect(Mod, <<"250">>, Port, undefined).

smtp_put(Mod, Message, Port) ->
    Mod:send(Port, [Message,<<"\r\n">>]).

smtp_expect(Mod, Code, Port, ErrorMsg) ->
    smtp_expect(Mod, Code, Port, ErrorMsg, 0, []).
smtp_expect(Mod, Code, Port, ErrorMsg, N, Acc) when is_binary(Code) ->
    case Mod:recv(Port, 0, 15000) of
    {ok, <<RespCode:3/binary, C, Rest/binary>> = Bin} when RespCode =:= Code ->
        case C of
        $  when Acc =:= [] ->
            {ok, trim_nl(Rest)};
        $  ->
            {ok, Acc};
        $- when N =:= 0 ->
            smtp_expect(Mod, Code, Port, ErrorMsg, N+1, Acc);
        $- ->
            ExtensionAcc = parse_extension(Rest, Acc),
            smtp_expect(Mod, Code, Port, ErrorMsg, N+1, ExtensionAcc);
        _ when ErrorMsg =:= undefined ->
            throw(Bin);
        _ ->
            throw(ErrorMsg)
        end;
    {ok, Other} when ErrorMsg =:= undefined ->
        throw(Other);
    {ok, _Other} ->
        throw(ErrorMsg);
    {error, closed} ->
        throw("Socket closed unexpectedly");
    {error, Reason} ->
        throw({Mod, recv, Reason, lists:flatten(inet:format_error(Reason))})
    end.

parse_extension(Bin, Acc) ->
    case binary:match(Bin, <<" ">>) of
    {I, _} ->
        <<E:I/binary, $ , Args/binary>> = Bin,
        [{to_upper(E), trim_nl(Args)} | Acc];
    nomatch ->
        case binary:match(Bin, <<"=">>) of
        nomatch ->
            [{to_upper(trim_nl(Bin)), true} | Acc];
        _ ->
            Acc
        end
    end.

to_upper(Bin)    -> to_upper(byte_size(Bin)-1, Bin).
to_upper(-1, Bin) -> Bin;
to_upper(I, Bin) ->
    case binary:at(Bin, I) of
    C when C >= $a, $z =< C ->
        list_to_binary(string:to_upper(binary_to_list(Bin)));
    _ ->
        to_upper(I-1, Bin)
    end.

trim_nl(Bin) ->
    case binary:match(Bin, [<<"\r">>, <<"\n">>]) of
    {I, _} ->
        binary:part(Bin, {0, I});
    nomatch ->
        Bin
    end.

print(debug, Fmt, Args) ->
    io:format("SMTP: " ++ Fmt, Args);
print(_, _Fmt, _Args) ->
    ok.

%% Add an . at all lines starting with a dot.

dot_escape(Data, NL) ->
    dot_escape(Data, NL, []).

dot_escape([], NL, Acc) ->
    {NL, lists:reverse(Acc)};
dot_escape([$.|Rest], true, Acc) ->
    dot_escape(Rest, false, [$.,$.|Acc]);
dot_escape([$\n|Rest], _, Acc) ->
    dot_escape(Rest, true, [$\n|Acc]);
dot_escape([C|Rest], _, Acc) ->
    dot_escape(Rest, false, [C|Acc]).

%%

sting2base64(String) ->
    sting2base64(String, []).

sting2base64([], Acc) ->
    lists:reverse(Acc);
sting2base64(String, Acc) ->
    case str2b64_line(String, []) of
    {ok, Line, Rest} ->
        sting2base64(Rest, ["\n",Line|Acc]);
    {more, Cont} ->
        lists:reverse(["\n",str2b64_end(Cont)|Acc])
    end.

%%

str2b64_line(S, [])           -> str2b64_line(S, [], 0);
str2b64_line(S, {Rest,Acc,N}) -> str2b64_line(Rest ++ S, Acc, N).

str2b64_line(S, Out, 76) -> {ok,lists:reverse(Out),S};
str2b64_line([C1,C2,C3|S], Out, N) ->
    O1 = e(C1 bsr 2),
    O2 = e(((C1 band 16#03) bsl 4) bor (C2 bsr 4)),
    O3 = e(((C2 band 16#0f) bsl 2) bor (C3 bsr 6)),
    O4 = e(C3 band 16#3f),
    str2b64_line(S, [O4,O3,O2,O1|Out], N+4);
str2b64_line(S, Out, N) ->
    {more,{S,Out,N}}.

%%

str2b64_end({[C1,C2],Out,_N}) ->
    O1 = e(C1 bsr 2),
    O2 = e(((C1 band 16#03) bsl 4) bor (C2 bsr 4)),
    O3 = e( (C2 band 16#0f) bsl 2 ),
    lists:reverse(Out, [O1,O2,O3,$=]);
str2b64_end({[C1],Out,_N}) ->
    O1 = e(C1 bsr 2),
    O2 = e((C1 band 16#03) bsl 4),
    lists:reverse(Out, [O1,O2,$=,$=]);
str2b64_end({[],Out,_N}) -> lists:reverse(Out);
str2b64_end([])          -> [].

%%

boundary_bin([]) ->
    undefined;
boundary_bin(_) ->
    rand:seed(exs64),
    <<"Boundary_(", (list_to_binary(random_list(10)))/binary, ")">>.

random_list(0) -> [];
random_list(N) -> [64+rand:uniform(25), 96+rand:uniform(25) | random_list(N-1)].

%%

e(X) when X >= 0,  X < 26 -> X + $A;
e(X) when X >= 26, X < 52 -> X + $a - 26;
e(X) when X >= 52, X < 62 -> X + $0 - 52;
e(62) -> $+;
e(63) -> $/;
e(X)  -> erlang:error({badchar,X}).

%%
mail_headers(_Key, [])   -> [];
mail_headers(Key, [H|T]) -> [mail_header(Key, H) | mail_headers(Key, T)].

mail_header(_Key, [])    -> [];
mail_header(Key, Val)    -> [Key, Val, <<"\r\n">>].