Send email

From Rosetta Code
(Redirected from Send an email)
Task
Send email
You are encouraged to solve this task according to the task description, using any language you may know.
Task

Write a function to send an email.

The function should have parameters for setting From, To and Cc addresses; the Subject, and the message text, and optionally fields for the server name and login details.

  • If appropriate, explain what notifications of problems/success are given.
  • Solutions using libraries or functions from the language are preferred, but failing that, external programs can be used with an explanation.
  • Note how portable the solution given is between operating systems when multi-OS languages are used.


(Remember to obfuscate any sensitive data used in examples)

Ada

Library: AWS
with AWS.SMTP, AWS.SMTP.Client, AWS.SMTP.Authentication.Plain;
with Ada.Text_IO;
use  Ada, AWS;

procedure Sendmail is
   Status : SMTP.Status;
   Auth : aliased constant SMTP.Authentication.Plain.Credential :=
      SMTP.Authentication.Plain.Initialize ("id", "password");
   Isp : SMTP.Receiver;
begin
   Isp :=
      SMTP.Client.Initialize
        ("smtp.mail.com",
         Port       => 5025,
         Credential => Auth'Unchecked_Access);
   SMTP.Client.Send
     (Isp,
      From    => SMTP.E_Mail ("Me", "me@some.org"),
      To      => SMTP.E_Mail ("You", "you@any.org"),
      Subject => "subject",
      Message => "Here is the text",
      Status  => Status);
   if not SMTP.Is_Ok (Status) then
      Text_IO.Put_Line
        ("Can't send message :" & SMTP.Status_Message (Status));
   end if;
end Sendmail;

AutoHotkey

ahk discussion

Library: COM.ahk
sSubject:= "greeting"
sText   := "hello"
sFrom   := "ahk@rosettacode"
sTo   := "whomitmayconcern"

sServer   := "smtp.gmail.com" ; specify your SMTP server
nPort     := 465 ; 25
bTLS      := True ; False
inputbox, sUsername, Username 
inputbox, sPassword, password

COM_Init()
pmsg :=   COM_CreateObject("CDO.Message")
pcfg :=   COM_Invoke(pmsg, "Configuration")
pfld :=   COM_Invoke(pcfg, "Fields")

COM_Invoke(pfld, "Item", "http://schemas.microsoft.com/cdo/configuration/sendusing", 2)
COM_Invoke(pfld, "Item", "http://schemas.microsoft.com/cdo/configuration/smtpconnectiontimeout", 60)
COM_Invoke(pfld, "Item", "http://schemas.microsoft.com/cdo/configuration/smtpserver", sServer)
COM_Invoke(pfld, "Item", "http://schemas.microsoft.com/cdo/configuration/smtpserverport", nPort)
COM_Invoke(pfld, "Item", "http://schemas.microsoft.com/cdo/configuration/smtpusessl", bTLS)
COM_Invoke(pfld, "Item", "http://schemas.microsoft.com/cdo/configuration/smtpauthenticate", 1)
COM_Invoke(pfld, "Item", "http://schemas.microsoft.com/cdo/configuration/sendusername", sUsername)
COM_Invoke(pfld, "Item", "http://schemas.microsoft.com/cdo/configuration/sendpassword", sPassword)
COM_Invoke(pfld, "Update")

COM_Invoke(pmsg, "Subject", sSubject)
COM_Invoke(pmsg, "From", sFrom)
COM_Invoke(pmsg, "To", sTo)
COM_Invoke(pmsg, "TextBody", sText)
COM_Invoke(pmsg, "Send")

COM_Release(pfld)
COM_Release(pcfg)
COM_Release(pmsg)
COM_Term()
#Include COM.ahk

BBC BASIC

Works with: BBC BASIC for Windows
      INSTALL @lib$+"SOCKLIB"
      
      Server$ = "smtp.gmail.com"
      From$   = "sender@somewhere"
      To$     = "recipient@elsewhere"
      CC$     = "another@nowhere"
      Subject$ = "Rosetta Code"
      Message$ = "This is a test of sending email."
      
      PROCsendmail(Server$, From$, To$, CC$, "", Subject$, "", Message$)
      END
      
      DEF PROCsendmail(smtp$,from$,to$,cc$,bcc$,subject$,replyto$,body$)
      LOCAL D%, S%, skt%, reply$
      DIM D% LOCAL 31, S% LOCAL 15
      
      SYS "GetLocalTime", S%
      SYS "GetDateFormat", 0, 0, S%, "ddd, dd MMM yyyy ", D%, 18
      SYS "GetTimeFormat", 0, 0, S%, "HH:mm:ss +0000", D%+17, 15
      D%?31 = 13
      
      PROC_initsockets
      skt% = FN_tcpconnect(smtp$,"mail")
      IF skt% <= 0 skt% = FN_tcpconnect(smtp$,"25")
      IF skt% <= 0 ERROR 100, "Failed to connect to SMTP server"
      IF FN_readlinesocket(skt%, 1000, reply$)
      WHILE FN_readlinesocket(skt%, 10, reply$) > 0 : ENDWHILE
      
      PROCsend(skt%,"HELO "+FN_gethostname)
      PROCmail(skt%,"MAIL FROM: ",from$)
      IF to$<>"" PROClist(skt%,to$)
      IF cc$<>"" PROClist(skt%,cc$)
      IF bcc$<>"" PROClist(skt%,bcc$)
      PROCsend(skt%, "DATA")
      
      IF FN_writelinesocket(skt%, "Date: "+$D%)
      IF FN_writelinesocket(skt%, "From: "+from$)
      IF FN_writelinesocket(skt%, "To: "+to$)
      IF cc$<>"" IF FN_writelinesocket(skt%, "Cc: "+cc$)
      IF subject$<>"" IF FN_writelinesocket(skt%, "Subject: "+subject$)
      IF replyto$<>"" IF FN_writelinesocket(skt%, "Reply-To: "+replyto$)
      IF FN_writelinesocket(skt%, "MIME-Version: 1.0")
      IF FN_writelinesocket(skt%, "Content-type: text/plain; charset=US-ASCII")
      
      IF FN_writelinesocket(skt%, "")
      IF FN_writelinesocket(skt%, body$)
      IF FN_writelinesocket(skt%, ".")
      
      PROCsend(skt%,"QUIT")
      
      PROC_exitsockets
      ENDPROC
      
      DEF PROClist(skt%,list$)
      LOCAL comma%
      REPEAT
        WHILE ASClist$=32 list$=MID$(list$,2):ENDWHILE
        comma% = INSTR(list$,",")
        IF comma% THEN
          PROCmail(skt%,"RCPT TO: ",LEFT$(list$,comma%-1))
          list$ = MID$(list$,comma%+1)
        ELSE
          PROCmail(skt%,"RCPT TO: ",list$)
        ENDIF
      UNTIL comma% = 0
      ENDPROC
      
      DEF PROCmail(skt%,cmd$,mail$)
      LOCAL I%,J%
      I% = INSTR(mail$,"<")
      J% = INSTR(mail$,">",I%)
      IF I% IF J% THEN
        PROCsend(skt%, cmd$+MID$(mail$,I%,J%-I%+1))
      ELSE
        PROCsend(skt%, cmd$+"<"+mail$+">")
      ENDIF
      ENDPROC
      
      DEF PROCsend(skt%,cmd$)
      LOCAL reply$
      IF FN_writelinesocket(skt%,cmd$) < 0 THEN ERROR 100, "Send failed"
      IF FN_readlinesocket(skt%, 200, reply$)
      WHILE FN_readlinesocket(skt%, 10, reply$) > 0 : ENDWHILE
      ENDPROC

C

Sends mail via the GMail SMTP server, requires libcurl

Library: libcurl
#include <curl/curl.h>
#include <string.h>
#include <stdio.h>

#define from    "<sender@duniya.com>"
#define to      "<addressee@gmail.com>"
#define cc      "<info@example.org>"
 
static const char *payload_text[] = {
  "Date: Mon, 13 Jun 2018 11:30:00 +0100\r\n",
  "To: " to "\r\n",
  "From: " from " (Example User)\r\n",
  "Cc: " cc " (Another example User)\r\n",
  "Message-ID: <ecd7db36-10ab-437a-9g3a-e652b9458efd@"
  "rfcpedant.example.org>\r\n",
  "Subject: Sanding mail via C\r\n",
  "\r\n",
  "This mail is being sent by a C program.\r\n",
  "\r\n",
  "It connects to the GMail SMTP server, by far, the most popular mail program of all.\r\n",
  "Which is also probably written in C.\r\n",
  "To C or not to C..............\r\n",
  "That is the question.\r\n",
  NULL
};
 
struct upload_status {
  int lines_read;
};
 
static size_t payload_source(void *ptr, size_t size, size_t nmemb, void *userp)
{
  struct upload_status *upload_ctx = (struct upload_status *)userp;
  const char *data;
 
  if((size == 0) || (nmemb == 0) || ((size*nmemb) < 1)) {
    return 0;
  }
 
  data = payload_text[upload_ctx->lines_read];
 
  if(data) {
    size_t len = strlen(data);
    memcpy(ptr, data, len);
    upload_ctx->lines_read++;
 
    return len;
  }
 
  return 0;
}
 
int main(void)
{
  CURL *curl;
  CURLcode res = CURLE_OK;
  struct curl_slist *recipients = NULL;
  struct upload_status upload_ctx;
 
  upload_ctx.lines_read = 0;
 
  curl = curl_easy_init();
  if(curl) {

    curl_easy_setopt(curl, CURLOPT_USERNAME, "user");
    curl_easy_setopt(curl, CURLOPT_PASSWORD, "secret");

    curl_easy_setopt(curl, CURLOPT_URL, "smtp://smtp.gmail.com:465");

    curl_easy_setopt(curl, CURLOPT_USE_SSL, (long)CURLUSESSL_ALL);
 
    curl_easy_setopt(curl, CURLOPT_CAINFO, "/path/to/certificate.pem");

    curl_easy_setopt(curl, CURLOPT_MAIL_FROM, from);

    recipients = curl_slist_append(recipients, to);
    recipients = curl_slist_append(recipients, cc);
    curl_easy_setopt(curl, CURLOPT_MAIL_RCPT, recipients);

    curl_easy_setopt(curl, CURLOPT_READFUNCTION, payload_source);
    curl_easy_setopt(curl, CURLOPT_READDATA, &upload_ctx);
    curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);

    curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);

    res = curl_easy_perform(curl);

    if(res != CURLE_OK)
      fprintf(stderr, "curl_easy_perform() failed: %s\n",curl_easy_strerror(res));

    curl_slist_free_all(recipients);

    curl_easy_cleanup(curl);
  }
 
  return (int)res;
}

C#

Works with: Mono version 1.2
Works with: Visual C# version 2003
static void Main(string[] args)
{
    //First of all construct the SMTP client

    SmtpClient SMTP = new SmtpClient("smtp.gmail.com", 587); //I have provided the URI and port for GMail, replace with your providers SMTP details
    SMTP.EnableSsl = true; //Required for gmail, may not for your provider, if your provider does not require it then use false.
    SMTP.DeliveryMethod = SmtpDeliveryMethod.Network;
    SMTP.Credentials = new NetworkCredential("YourUserName", "YourPassword");
    MailMessage Mail = new MailMessage("yourEmail@address.com", "theirEmail@address.com");


    //Then we construct the message

    Mail.Subject = "Important Message";
    Mail.Body = "Hello over there"; //The body contains the string for your email
    //using "Mail.IsBodyHtml = true;" you can put an HTML page in your message body

    //Then we use the SMTP client to send the message

    SMTP.Send(Mail);

    Console.WriteLine("Message Sent");
}

C++

Library: POCO
Works with: POCO version 1.3.6
// on Ubuntu: sudo apt-get install libpoco-dev
// or see http://pocoproject.org/
// compile with: g++ -Wall -O3 send-mail-cxx.C -lPocoNet -lPocoFoundation

#include <cstdlib>
#include <iostream>
#include <Poco/Net/SMTPClientSession.h>
#include <Poco/Net/MailMessage.h>

using namespace Poco::Net;

int main (int argc, char **argv)
{
  try
    {
      MailMessage msg;

      msg.addRecipient (MailRecipient (MailRecipient::PRIMARY_RECIPIENT,
                                       "alice@example.com",
                                       "Alice Moralis"));
      msg.addRecipient (MailRecipient (MailRecipient::CC_RECIPIENT,
                                       "pat@example.com",
                                       "Patrick Kilpatrick"));
      msg.addRecipient (MailRecipient (MailRecipient::BCC_RECIPIENT,
                                       "mike@example.com",
                                       "Michael Carmichael"));

      msg.setSender ("Roy Kilroy <roy@example.com>");

      msg.setSubject ("Rosetta Code");
      msg.setContent ("Sending mail from C++ using POCO C++ Libraries");

      SMTPClientSession smtp ("mail.example.com"); // SMTP server name
      smtp.login ();
      smtp.sendMessage (msg);
      smtp.close ();
      std::cerr << "Sent mail successfully!" << std::endl;
    }
  catch (std::exception &e)
    {
      std::cerr << "failed to send mail: " << e.what() << std::endl;
      return EXIT_FAILURE;
    }

  return EXIT_SUCCESS;
}

When run literally as above, should print: 

failed to send mail: Host not found

since mail.example.com does not exist. To get it to work, you'll need to fill in the name of an SMTP server (such as the one provided by your ISP), and you should adjust the addresses of the sender and the recipient(s).

This version does not do authentication. However, the login() method can accept a username and password for authentication. Also, newer versions of POCO provide SecureSMTPClientSession, for doing STARTTLS.

Clojure

Library: postal

Postal wraps JavaMail to make sending emails simple and platform independent. 

(require '[postal.core :refer [send-message]])

(send-message {:host "smtp.gmail.com"
               :ssl true
               :user your_username
               :pass your_password}
              {:from "you@yourdomain.com"
               :to ["your_friend@example.com"]
               :cc ["bob@builder.com" "dora@explorer.com"]
               :subject "Yo"
               :body "Testing."})
Output:
{:error :SUCCESS, :code 0, :message "messages sent"}

D

Requires the libcurl library to be installed on the system. 

void main() {
    import std.net.curl;

    auto s = SMTP("smtps://smtp.gmail.com");
    s.setAuthentication("someuser@gmail.com", "somepassword");
    s.mailTo = ["<friend@example.com>"];
    s.mailFrom = "<someuser@gmail.com>";
    s.message = "Subject:test\n\nExample Message";
    s.perform;
}

Delphi 

procedure SendEmail;
var
  msg: TIdMessage;
  smtp: TIdSMTP;
begin
  smtp := TIdSMTP.Create;
  try
    smtp.Host := 'smtp.server.com';
    smtp.Port := 587;
    smtp.Username := 'login';
    smtp.Password := 'password';
    smtp.AuthType := satNone;
    smtp.Connect;
    msg := TIdMessage.Create(nil);
    try
      with msg.Recipients.Add do begin
        Address := 'doug@gmail.com';
        Name := 'Doug';
      end;
      with msg.Sender do begin
        Address := 'fred@server.com';
        Name := 'Fred';
      end;
      msg.Subject := 'subj';
      msg.Body.Text := 'here goes email message';
      smtp.Send(msg);
    finally
      msg.Free;
    end;
  finally
    smtp.Free;
  end;
end;

Diego

This instruction instructs a thing in the mist to send an email. It understands that the found thing will have email knowledge (similar to libraries in other languages). If the caller does not have email knowledge, the callee will train the caller on first request. It is at the discretion of the callee to adjust, delay or not send the email. 

begin_instruct(Send email)_param({str} from, to, cc, subject, msg, {html}, htmlmsg)_opt({cred}, login)_ns(rosettacode);
    set_thread(linger);
    find_thing()_first()_email()
        ? with_found()_label(emailer);
        : exit_instruct[]_err(Sorry, no one can send emails!);
    ;
    with_[emailer]_format(html)
        ? with_[emailer]_cred[login]_email[htmlmsg]_from[from]_to[to]_cc[cc]_subject[subject];
            : exit_instruct[]_err(Something went wrong with the email);
        : with_[emailer]_cred[login]_email[msg]_from[from]_to[to]_cc[cc]_subject[subject];
            : exit_instruct[]_err(Something went wrong with the email);
    ;
    reset_thread();
end_instruct[];

set_namespace(rosettacode);

// Set up credentials
add_var({cred}, mycred)_server(esvr1)_username(bob)_password(p@$$w0rd);  // Other credentials can be added here

// Send email:
exec_instruct(Send email)_param()
    _from(bob@bobmail.com.invalid)  // It is at the discretion of the caller to use this from address 
    _to(fred@bobmail.com.invalid)
    _cc(jill@bobmail.com.invalid)
    _subject(Rosettacode wants me to send an email!)
    _msg(This is the body of my email.)
    _htmlmsg(<b>This is the body of my email, in bold</b>)
    _login[mycred]
_me();

reset_namespace();

Emacs Lisp

Variable send-mail-function holds a function for sending a message from the current buffer. The user or sysadmin is expected to set that variable to a preferred method (sendmail, SMTP, etc). The default queries the user for initial setup. 

(defun my-send-email (from to cc subject text)
  (with-temp-buffer
    (insert "From: " from "\n"
            "To: " to "\n"
            "Cc: " cc "\n"
            "Subject: " subject "\n"
            mail-header-separator "\n"
            text)
    (funcall send-mail-function)))

(my-send-email "from@example.com" "to@example.com" ""
               "very important"
               "body\ntext\n")

The buffer filling here pays no attention to charset or possible special characters in the fields or text.

(For user-level interactive mailing, compose-mail creates and pre-fills a message buffer ready for the user to edit and send, or not send.)

Factor

This one uses the build-in SMTP vocabulary. Note that 'to' and 'cc' need to be arrays of strings containing an email address. 

 
USING: accessors io.sockets locals namespaces smtp ;
IN: scratchpad
:: send-mail ( f t c s b -- )
    default-smtp-config "smtp.gmail.com" 587 <inet> >>server
    t >>tls?
    "my.gmail.address@gmail.com" "qwertyuiasdfghjk" <plain-auth>
    >>auth \ smtp-config set-global <email> f >>from t >>to
    c >>cc s >>subject b >>body send-email ;

Fantom

There's a built-in Email library, which will work on the JVM, CLR and Javascript runtimes. Errors are thrown if there is a problem with the protocol or the network. 

using email

class Mail
{
  // create a client for sending email - add your own host/username/password
  static SmtpClient makeClient ()
  {
    client := SmtpClient
    {
      host     = "yourhost"
      username = "yourusername"
      password = "yourpassword"
    }
    return client
  }

  public static Void main()
  {
    // create email
    email := Email
    {
      to = ["to@addr"]
      from = "from@addr"
      cc = ["cc@addr"]
      subject = test"
      body = TextPart { text = "test email" }
    }

    // create client and send email
    makeClient.send (email)
  }
}

Fortran

Intel Fortran on Windows

Using Outlook COM server. Before compiling the program, it's necessary to use the Intel Fortran Module Wizard from the Visual Studio editor, to generate a Fortran module for the Microsoft Outlook Object Library. The following program has to be linked with this module (msoutl). 

program sendmail
    use ifcom
    use msoutl
    implicit none
    integer(4) :: app, status, msg
    
    call cominitialize(status)
    call comcreateobject("Outlook.Application", app, status)
    msg = $Application_CreateItem(app, olMailItem, status)
    call $MailItem_SetTo(msg, "somebody@somewhere", status)
    call $MailItem_SetSubject(msg, "Title", status)
    call $MailItem_SetBody(msg, "Hello", status)
    call $MailItem_Send(msg, status)
    call $Application_Quit(app, status)
    call comuninitialize()
end program

FreeBASIC

FB: LINUX

Unfortunately, FreeBASIC does not have a built-in library for sending emails. However, you can use an external program such as sendmail or mailx that can be invoked from FreeBASIC using the SHELL function. 

Sub SendEmail(fromAddress As String, toAddress As String, ccAddress As String, _
    subject As String, messageText As String, serverName As String, loginDetails As String)
    Dim As String comando
    comando = "echo '" & messageText & "' | mailx -s '" & subject & "' -r '" _
    & fromAddress & "' -S smtp='" & serverName _
    & "' -S smtp-auth=login -S smtp-auth-user='" & loginDetails _
    & "' -S smtp-auth-password='yourpassword' -c '" & ccAddress & "' '" _
    & toAddress & "'"
    Shell comando
End Sub

Dim As String fromAddress = "your_mail@gmail.com"
Dim As String toAddress = "recipient@gmail.com"
Dim As String ccAddress = "cc@gmail.com"
Dim As String subject = "Mail subject"
Dim As String messageText = "This is the body of the email."
Dim As String serverName = "smtp.gmail.com"
Dim As String loginDetails = "your_username"

And then call this script from FreeBASIC using the SHELL function: 

SendEmail(fromAddress, toAddress, ccAddress, subject, messageText, serverName, loginDetails)

FB: WINDOWS

FreeBASIC does not have a built-in library for interacting with Outlook. An alternative is to write a script in VBA or VBScript to send email through Outlook, and then call that script from FreeBASIC. 

'VBScript code:
Function EnviarCorreo()
    With CreateObject("CDO.Message")
        .Subject = "Mail subject"
        .From = "your_mail@domain.com"
        .To = "recipient@domain.com"
        .TextBody = "This is the body of the email."
        
        .Configuration.Fields.Item _
        ("http://schemas.microsoft.com/cdo/configuration/sendusing") = 2
        
        .Configuration.Fields.Item _
        ("http://schemas.microsoft.com/cdo/configuration/smtpserver") = _
        "smtp.dominio.com"
        
        .Configuration.Fields.Item _
        ("http://schemas.microsoft.com/cdo/configuration/smtpserverport") = 25
        
        .Configuration.Fields.Update
        .Send
    End With
End Function

'VBA code:
Sub EnviarCorreo()
    Dim OutlookApp As Object
    Dim OutlookMail As Object
    Set OutlookApp = CreateObject("Outlook.Application")
    Set OutlookMail = OutlookApp.CreateItem(0)
    With OutlookMail
        .To = "recipient@domain.com"
        .Subject = "Mail subject"
        .Body = "This is the body of the email."
        .Send
    End With
    Set OutlookMail = Nothing
    Set OutlookApp = Nothing
End Sub

And then call this script from FreeBASIC using the SHELL function: 

Shell "cscript send_mail.vbs"

Go

A full little command-line program that can be used to send simple e-mails. Uses the built-in smtp package. Supports TLS connections. 

package main

import (
	"bufio"
	"bytes"
	"errors"
	"flag"
	"fmt"
	"io/ioutil"
	"net/smtp"
	"os"
	"strings"
)

type Message struct {
	From    string
	To      []string
	Cc      []string
	Subject string
	Content string
}

func (m Message) Bytes() (r []byte) {
	to := strings.Join(m.To, ",")
	cc := strings.Join(m.Cc, ",")

	r = append(r, []byte("From: "+m.From+"\n")...)
	r = append(r, []byte("To: "+to+"\n")...)
	r = append(r, []byte("Cc: "+cc+"\n")...)
	r = append(r, []byte("Subject: "+m.Subject+"\n\n")...)
	r = append(r, []byte(m.Content)...)

	return
}

func (m Message) Send(host string, port int, user, pass string) (err error) {
	err = check(host, user, pass)
	if err != nil {
		return
	}

	err = smtp.SendMail(fmt.Sprintf("%v:%v", host, port),
		smtp.PlainAuth("", user, pass, host),
		m.From,
		m.To,
		m.Bytes(),
	)

	return
}

func check(host, user, pass string) error {
	if host == "" {
		return errors.New("Bad host")
	}
	if user == "" {
		return errors.New("Bad username")
	}
	if pass == "" {
		return errors.New("Bad password")
	}

	return nil
}

func main() {
	var flags struct {
		host string
		port int
		user string
		pass string
	}
	flag.StringVar(&flags.host, "host", "", "SMTP server to connect to")
	flag.IntVar(&flags.port, "port", 587, "Port to connect to SMTP server on")
	flag.StringVar(&flags.user, "user", "", "Username to authenticate with")
	flag.StringVar(&flags.pass, "pass", "", "Password to authenticate with")
	flag.Parse()

	err := check(flags.host, flags.user, flags.pass)
	if err != nil {
		flag.Usage()
		os.Exit(1)
	}

	bufin := bufio.NewReader(os.Stdin)

	fmt.Printf("From: ")
	from, err := bufin.ReadString('\n')
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		os.Exit(1)
	}
	from = strings.Trim(from, " \t\n\r")

	var to []string
	for {
		fmt.Printf("To (Blank to finish): ")
		tmp, err := bufin.ReadString('\n')
		if err != nil {
			fmt.Printf("Error: %v\n", err)
			os.Exit(1)
		}
		tmp = strings.Trim(tmp, " \t\n\r")

		if tmp == "" {
			break
		}

		to = append(to, tmp)
	}

	var cc []string
	for {
		fmt.Printf("Cc (Blank to finish): ")
		tmp, err := bufin.ReadString('\n')
		if err != nil {
			fmt.Printf("Error: %v\n", err)
			os.Exit(1)
		}
		tmp = strings.Trim(tmp, " \t\n\r")

		if tmp == "" {
			break
		}

		cc = append(cc, tmp)
	}

	fmt.Printf("Subject: ")
	subject, err := bufin.ReadString('\n')
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		os.Exit(1)
	}
	subject = strings.Trim(subject, " \t\n\r")

	fmt.Printf("Content (Until EOF):\n")
	content, err := ioutil.ReadAll(os.Stdin)
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		os.Exit(1)
	}
	content = bytes.Trim(content, " \t\n\r")

	m := Message{
		From:    from,
		To:      to,
		Cc:      cc,
		Subject: subject,
		Content: string(content),
	}

	fmt.Printf("\nSending message...\n")
	err = m.Send(flags.host, flags.port, flags.user, flags.pass)
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		os.Exit(1)
	}

	fmt.Printf("Message sent.\n")
}

Groovy

From [1] we can get email solution for Groovy 

import javax.mail.*
import javax.mail.internet.*
 
public static void simpleMail(String from, String password, String to,
    String subject, String body) throws Exception {
 
    String host = "smtp.gmail.com";
    Properties props = System.getProperties();
    props.put("mail.smtp.starttls.enable",true);
    /* mail.smtp.ssl.trust is needed in script to avoid error "Could not convert socket to TLS"  */
    props.setProperty("mail.smtp.ssl.trust", host);
    props.put("mail.smtp.auth", true);      
    props.put("mail.smtp.host", host);
    props.put("mail.smtp.user", from);
    props.put("mail.smtp.password", password);
    props.put("mail.smtp.port", "587");
 
    Session session = Session.getDefaultInstance(props, null);
    MimeMessage message = new MimeMessage(session);
    message.setFrom(new InternetAddress(from));
 
    InternetAddress toAddress = new InternetAddress(to);
 
    message.addRecipient(Message.RecipientType.TO, toAddress);
 
    message.setSubject(subject);
    message.setText(body);
 
    Transport transport = session.getTransport("smtp");
 
    transport.connect(host, from, password);
 
    transport.sendMessage(message, message.getAllRecipients());
    transport.close();
}
 
/* Set email address sender */
String s1 = "example@gmail.com";
 
/* Set password sender */
String s2 = "";
 
/* Set email address sender */
String s3 = "example@gmail.com"
 
/*Call function */
simpleMail(s1, s2 , s3, "TITLE", "TEXT");

Haskell

Example using smtp-mail package: 

{-# LANGUAGE OverloadedStrings #-}

module Main (main) where

import           Network.Mail.SMTP
                    ( Address(..)
                    , htmlPart
                    , plainTextPart
                    , sendMailWithLogin'
                    , simpleMail
                    )

main :: IO ()
main =
    sendMailWithLogin' "smtp.example.com" 25 "user" "password" $
        simpleMail
            (Address (Just "From Example") "from@example.com")
            [Address (Just "To Example") "to@example.com"]
            [] -- CC
            [] -- BCC
            "Subject"
            [ plainTextPart "This is plain text."
            , htmlPart "<h1>Title</h1><p>This is HTML.</p>"
            ]

Icon and Unicon

A Unicon-specific solution is: 

procedure main(args)
    mail := open("mailto:"||args[1], "m", "Subject : "||args[2],
                 "X-Note: automatically send by Unicon") |
            stop("Cannot send mail to ",args[1])
    every write(mail , !&input)
    close (mail)
end

Java 

import java.util.Properties;

import javax.mail.MessagingException;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.Message.RecipientType;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;

/**
 * Mail
 */
public class Mail
{
 /**
  * Session
  */
 protected Session session;

 /**
  * Mail constructor.
  * 
  * @param host Host
  */
 public Mail(String host)
 {
  Properties properties = new Properties();
  properties.put("mail.smtp.host", host);
  session = Session.getDefaultInstance(properties);
 }

 /**
  * Send email message.
  *
  * @param from From
  * @param tos Recipients
  * @param ccs CC Recipients
  * @param subject Subject
  * @param text Text
  * @throws MessagingException
  */
 public void send(String from, String tos[], String ccs[], String subject,
        String text)
        throws MessagingException
 {
  MimeMessage message = new MimeMessage(session);
  message.setFrom(new InternetAddress(from));
  for (String to : tos)
   message.addRecipient(RecipientType.TO, new InternetAddress(to));
  for (String cc : ccs)
   message.addRecipient(RecipientType.TO, new InternetAddress(cc));
  message.setSubject(subject);
  message.setText(text);
  Transport.send(message);
 }
}

Julia 

using SMTPClient

addbrackets(s) = replace(s, r"^\s*([^\<\>]+)\s*$", s"<\1>")

function wrapRFC5322(from, to, subject, msg)
    timestr = Libc.strftime("%a, %d %b %Y %H:%M:%S %z", time())
    IOBuffer("Date: $timestr\nTo: $to\nFrom: $from\nSubject: $subject\n\n$msg")
end

function sendemail(from, to, subject, messagebody, serverandport;
                   cc=[], user="", password="", isSSL=true, blocking=true)
    opt = SendOptions(blocking=blocking, isSSL=isSSL, username=user, passwd=password)
    send(serverandport, map(s -> addbrackets(s), vcat(to, cc)), addbrackets(from),
         wrapRFC5322(addbrackets(from), addbrackets(to), subject, messagebody), opt)
end

sendemail("to@example.com", "from@example.com", "TEST", "hello there test message text here", "smtps://smtp.gmail.com",
          user="from@example.com", password="example.com")

Kotlin

To compile and run this program 'javax.mail.jar' will need to be present on your system and added to your classpath. Also if you're using the Google SMTP Server then, as well as requiring a gmail account, you'll probably need to temporarily turn on 'access for less secure apps' to prevent it from being blocked. 

// version 1.1.4-3

import java.util.Properties
import javax.mail.Authenticator
import javax.mail.PasswordAuthentication
import javax.mail.Session
import javax.mail.internet.MimeMessage
import javax.mail.internet.InternetAddress
import javax.mail.Message.RecipientType
import javax.mail.Transport

fun sendEmail(user: String, tos: Array<String>, ccs: Array<String>, title: String,
              body: String, password: String) {
    val props = Properties()
    val host = "smtp.gmail.com"
    with (props) {
        put("mail.smtp.host", host)
        put("mail.smtp.port", "587") // for TLS
        put("mail.smtp.auth", "true")
        put("mail.smtp.starttls.enable", "true")
    }
    val auth = object: Authenticator() {
        protected override fun getPasswordAuthentication() =
            PasswordAuthentication(user, password)
    }
    val session = Session.getInstance(props, auth)
    val message = MimeMessage(session)
    with (message) {
        setFrom(InternetAddress(user))
        for (to in tos) addRecipient(RecipientType.TO, InternetAddress(to))
        for (cc in ccs) addRecipient(RecipientType.TO, InternetAddress(cc))
        setSubject(title)
        setText(body)
    }
    val transport = session.getTransport("smtp")
    with (transport) {
        connect(host, user, password)
        sendMessage(message, message.allRecipients)
        close()
    }
}

fun main(args: Array<String>) {
    val user = "some.user@gmail.com"
    val tos = arrayOf("other.user@otherserver.com")
    val ccs = arrayOf<String>()
    val title = "Rosetta Code Example"
    val body = "This is just a test email"
    val password = "secret"
    sendEmail(user, tos, ccs, title, body, password)
}

Lasso

This example leverages Lasso's built in Email_Send method. 

// with a lot of unneeded params.
// sends plain text and html in same email 
// simple usage is below
email_send(
	-host = 'mail.example.com', 
	-port = 25, 
	-timeout = 100, 
	-username = 'user.name', 
	-password = 'secure_password', 
	-priority = 'immediate', 
	-to = 'joe@average.com', 
	-cc = 'jane@average.com', 
	-bcc = 'me@too.com', 
	-from = 'lasso@example.com', 
	-replyto = 'lassorocks@example.com', 
	-sender = 'lasso@example.com', 
	-subject = 'Lasso is awesome', 
	-body = 'Lasso is awesome, you should try it!', 
	-html = '<p>Lasso is <b>awesome</b>, you should try it!</p>', 
	-attachments = '/path/to/myFile.txt'
)

// simple usage
// sends plan text email
email_send(
	-host = 'mail.example.com', 
	-username = 'user.name', 
	-password = 'secure_password', 
	-to = 'joe@average.com', 
	-from = 'lasso@example.com', 
	-subject = 'Lasso is awesome', 
	-body = 'Lasso is awesome, you should try it!'
)

Liberty BASIC

This program requires sendemail.exe and sendemail.pl in the same directory, available free from Caspian's SendEmail Site. 

text$       = "This is a simple text message."

from$       = "user@diga.me.es"
username$   = "me@diga.me.es"
'password$   = "***********"
recipient$  = "somebody@gmail.com"
server$     = "auth.smtp.1and1.co.uk:25"
subject$    = chr$( 34) +text$          +chr$( 34)  '   Use quotes to allow spaces in text.
message$    = chr$( 34) +"Hello world." +chr$( 34)
attach$     = "a.txt"
logfile$    = "sendemail.log"

cmd$ = " -f ";  from$;_             'from
       " -t ";  recipient$;_        'to
       " -u ";  subject$;_          'subject
       " -s ";  server$;_           'server
       " -m ";  message$;_          'message
       " -a ";  attach$;_           'file to attach
       " -l ";  logfile$;_          'file to log result in
       " -xu "; username$         'smtp user name
       '" -xp "; password$           'smtp password not given so will ask in a CMD window

run "sendEmail.exe "; cmd$, HIDE

end

Lingo

Lingo has no built-in support for sending email. But this can be achieved e.g. by using Shell Xtra and one of the available command-line SMTP clients.

Library: Shell Xtra
----------------------------------------
-- Sends email via SMTP using senditquiet.exe (15 KB)
-- @param {string} fromAddr
-- @param {string} toAddr - multiple addresses separated with ;
-- @param {string} subject
-- @param {string} message - use "\n" for line breaks
-- @param {string} [cc=VOID] - optional; multiple addresses separated with ;
-- @param {string} [bcc=VOID] - optional; multiple addresses separated with ;
-- @param {propList} [serverProps=VOID] - optional; allows to overwrite default settings
-- @return {bool} success
----------------------------------------
on sendEmail (fromAddr, toAddr, subject, message, cc, bcc, serverProps)
  
  sx = xtra("Shell").new()
  
  -- senditquiet.exe in folder "bin" relative to current movie
  sx.shell_setcurrentdir(_movie.path&"bin")
  
  -- defaults
  host = "smtp.gmail.com"
  protocol = "ssl"
  port = 587
  user = "johndoe"
  pass = "foobar"
  
  -- if propList 'serverProps' was passed, overwrite defaults
  if ilk(serverProps)=#propList then
    repeat with i = 1 to serverProps.count
      do(serverProps.getPropAt(i)&"="&QUOTE&serverProps[i]&QUOTE)
    end repeat
  end if

  cmd = "senditquiet"
  put " -s "&host after cmd
  put " -protocol "&protocol after cmd
  put " -port "&port after cmd
  put " -u "&user after cmd
  put " -p "&pass after cmd
  
  put " -f "&QUOTE&fromAddr&QUOTE after cmd
  put " -t "&QUOTE&toAddr&QUOTE after cmd
  put " -subject "&QUOTE&subject&QUOTE after cmd
  put " -body "&QUOTE&message&QUOTE after cmd
  
  -- optional args
  if not voidP(cc) then put " -cc "&QUOTE&cc&QUOTE after cmd
  if not voidP(bcc) then put " -bcc "&QUOTE&bcc&QUOTE after cmd

  put " 1>nul 2>nul & if errorlevel 1 echo ERROR" after cmd
  
  res = sx.shell_cmd(cmd)
  return not(res contains "ERROR")  
end

LiveCode

LiveCode provides a built-in method that will create an email in the registered mailto: handler on supported OS. 

revMail "help@example.com",,"Help!",field "Message"

To create and send an email in LiveCode requires coding your own smtp client, or using one of a couple of 3rd party stacks.

LotusScript 

Dim session As New NotesSession
Dim db As NotesDatabase
Dim doc As NotesDocument
Set db = session.CurrentDatabase
Set doc = New NotesDocument( db )
doc.Form = "Memo"
doc.SendTo = "John Doe"
doc.Subject = "Subject of this mail"
Call doc.Send( False )

Lua

Using LuaSocket's SMTP module (from the documentation on that page): 

-- load the smtp support
local smtp = require("socket.smtp")

-- Connects to server "localhost" and sends a message to users
-- "fulano@example.com",  "beltrano@example.com", 
-- and "sicrano@example.com".
-- Note that "fulano" is the primary recipient, "beltrano" receives a
-- carbon copy and neither of them knows that "sicrano" received a blind
-- carbon copy of the message.
from = "<luasocket@example.com>"

rcpt = {
  "<fulano@example.com>",
  "<beltrano@example.com>",
  "<sicrano@example.com>"
}

mesgt = {
  headers = {
    to = "Fulano da Silva <fulano@example.com>",
    cc = '"Beltrano F. Nunes" <beltrano@example.com>',
    subject = "My first message"
  },
  body = "I hope this works. If it does, I can send you another 1000 copies."
}

r, e = smtp.send{
  from = from,
  rcpt = rcpt, 
  source = smtp.message(mesgt)
}

Mathematica /Wolfram Language

Mathematica has the built-in function SendMail, example: 

SendMail["From" -> "from@email.com", "To" -> "to@email.com", 
 "Subject" -> "Sending Email from Mathematica", "Body" -> "Hello world!", 
 "Server" -> "smtp.email.com"]

The following options can be specified: 

"To"
"Cc"
"Bcc"
"Subject"
"Body"
"Attachments"
"From"
"Server"
"EncryptionProtocol"
"Fullname"
"Password"
"PortNumber"
"ReplyTo"
"ServerAuthentication"
"UserName"

Possible options for EncryptionProtocol are: "SSL","StartTLS" and "TLS". This function should work fine on all the OS's Mathematica runs, which includes the largest 3: Windows, Linux, Mac OSX.

NewLISP

  • using library smtp.lsp
(module "smtp.lsp") 
(SMTP:send-mail "user@asite.com" "somebody@isp.com" "Greetings" "How are you today? - john doe -" "smtp.asite.com" "user" "password")

Nim

Compile with nim c -d:ssl mail 

import smtp

proc sendMail(fromAddr: string; toAddrs, ccAddrs: seq[string];
              subject, message, login, password: string;
              server = "smtp.gmail.com"; port = Port 465; ssl = true) =
  let msg = createMessage(subject, message, toAddrs, ccAddrs)
  let session = newSmtp(useSsl = ssl, debug = true)
  session.connect(server, port)
  session.auth(login, password)
  session.sendMail(fromAddr, toAddrs, $msg)

sendMail(fromAddr = "nim@gmail.com",
         toAddrs  = @["someone@example.com"],
         ccAddrs  = @[],
         subject  = "Hi from Nim",
         message  = "Nim says hi!\nAnd bye again!",
         login    = "nim@gmail.com",
         password = "XXXXXX")

OCaml 

let h = Smtp.connect "smtp.gmail.fr";;
Smtp.helo h "hostname";;
Smtp.mail h "<john.smith@example.com>";;
Smtp.rcpt h "<john-doe@example.com>";;
let email_header = "\
From: John Smith <john.smith@example.com>
To: John Doe <john-doe@example.com>
Subject: surprise";;
let email_msg = "Happy Birthday";;
Smtp.data h (email_header ^ "\r\n\r\n" ^ email_msg);;
Smtp.quit h;;

Perl

Using Net::SMTP

This subroutine throws an appropriate error if it fails to connect to the server or authenticate. It should work on any platform Perl does. 

use Net::SMTP;
use Authen::SASL;
  # Net::SMTP's 'auth' method needs Authen::SASL to work, but
  # this is undocumented, and if you don't have the latter, the
  # method will just silently fail. Hence we explicitly use
  # Authen::SASL here.

sub send_email {
  my %o =
     (from => '', to => [], cc => [],
      subject => '', body => '',
      host => '', user => '', password => '',
      @_);
  ref $o{$_} or $o{$_} = [$o{$_}] foreach 'to', 'cc';

  my $smtp = Net::SMTP->new($o{host} ? $o{host} : ())
      or die "Couldn't connect to SMTP server";

  $o{password} and
     $smtp->auth($o{user}, $o{password}) ||
     die 'SMTP authentication failed';

  $smtp->mail($o{user});
  $smtp->recipient($_) foreach @{$o{to}}, @{$o{cc}};
  $smtp->data;
  $o{from} and $smtp->datasend("From: $o{from}\n");
  $smtp->datasend('To: ' . join(', ', @{$o{to}}) . "\n");
  @{$o{cc}} and $smtp->datasend('Cc: ' . join(', ', @{$o{cc}}) . "\n");
  $o{subject} and $smtp->datasend("Subject: $o{subject}\n");
  $smtp->datasend("\n$o{body}");
  $smtp->dataend;

  return 1;
}

An example call: 

send_email
   from => 'A. T. Tappman',
   to => ['suchandsuch@example.com', 'soandso@example.org'],
   cc => 'somebodyelse@example.net',
   subject => 'Important message',
   body => 'I yearn for you tragically.',
   host => 'smtp.example.com:587',
   user => 'tappman@example.com',
   password => 'yossarian';

If the host parameter is omitted, send_email falls back on the SMTP_Hosts defined in Net::Config. Hence, only two arguments are strictly necessary: 

send_email
   to => 'suchandsuch@example.com',
   user => 'tappman@example.com';

Using LWP

LWP can send email by a POST to a mailto: URL. The message is given as a HTTP request. This is mainly of interest for treating different types of URLs in a common way. LWP sends merely by running the sendmail program, or on MacOS classic by SMTP (to SMTPHOSTS environment variable). For reference, the $ua->post() method does not suit since it constructs a message as MIME "form data". 

use strict;
use LWP::UserAgent;
use HTTP::Request;

sub send_email {
  my ($from, $to, $cc, $subject, $text) = @_;

  my $ua = LWP::UserAgent->new;
  my $req = HTTP::Request->new (POST => "mailto:$to",
                                [ From => $from,
                                  Cc => $cc,
                                  Subject => $subject ],
                                $text);
  my $resp = $ua->request($req);
  if (! $resp->is_success) {
    print $resp->status_line,"\n";
  }
}

send_email('from-me@example.com', 'to-foo@example.com', '',
           "very important subject",
           "Body text\n");

Phix

Library: Phix/libcurl
Translation of: C

Obviously, USER/PWD/URL/etc. would all need altering for your details. For gmail, make sure you enable https://myaccount.google.com/lesssecureapps 

without js -- (libcurl)
include builtins\libcurl.e 
 
constant USER = "you@gmail.com",
         PWD = "secret",
         URL = "smtps://smtp.gmail.com:465",
         FROM = "sender@gmail.com",
         TO = "addressee@email.com",
         CC = "info@example.org",
         FMT = "Date: Mon, 13 Jun 2018 11:30:00 +0100\r\n"&
               "To: %s\r\n"&
               "From: %s (Example User)\r\n"&
               "Cc: %s (Another example User)\r\n"&
               "Subject: Sanding mail via Phix\r\n"&
               "\r\n"&
               "This mail is being sent by a Phix program.\r\n"&
               "\r\n"&
               "It connects to the GMail SMTP server, by far the most popular mail program of all.\r\n"&
               "Which is, however, probably not written in Phix.\r\n"
 
function read_callback(atom pbuffer, integer size, nmemb, atom pUserData)
    -- copy a maximum of size*nmemb bytes into pbuffer
    if size==0 or nmemb==0 or size*nmemb<1 then return 0 end if
    {integer sent, integer len, atom pPayload} = peekns({pUserData,3})
    integer bytes_written = min(size*nmemb,len-sent)
    mem_copy(pbuffer,pPayload+sent,bytes_written)
    sent += bytes_written
    pokeN(pUserData,sent,machine_word())
    return bytes_written
end function
constant read_cb = call_back({'+',routine_id("read_callback")})
 
constant string payload_text = sprintf(FMT,{TO,FROM,CC})
 
curl_global_init()
CURLcode res = CURLE_OK
atom slist_recipients = NULL
atom curl = curl_easy_init()
curl_easy_setopt(curl, CURLOPT_USERNAME, USER)
curl_easy_setopt(curl, CURLOPT_PASSWORD, PWD)
curl_easy_setopt(curl, CURLOPT_URL, URL)
curl_easy_setopt(curl, CURLOPT_USE_SSL, CURLUSESSL_ALL)
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0)
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0)
curl_easy_setopt(curl, CURLOPT_MAIL_FROM, FROM)
slist_recipients = curl_slist_append(slist_recipients, TO)
slist_recipients = curl_slist_append(slist_recipients, CC)
curl_easy_setopt(curl, CURLOPT_MAIL_RCPT, slist_recipients)
curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_cb);
atom pUserData = allocate(machine_word()*3),
     pPayload = allocate_string(payload_text)
pokeN(pUserData,{0,length(payload_text),pPayload},machine_word())
curl_easy_setopt(curl, CURLOPT_READDATA, pUserData)
curl_easy_setopt(curl, CURLOPT_UPLOAD, true)
--curl_easy_setopt(curl, CURLOPT_VERBOSE, true)
res = curl_easy_perform(curl)
if res!=CURLE_OK then
    printf(2, "curl_easy_perform() failed: %d (%s)\n",{res,curl_easy_strerror(res)})
end if 
curl_slist_free_all(slist_recipients)
curl_easy_cleanup(curl)
curl_global_cleanup()

PHP 

mail('hello@world.net', 'My Subject', "A Message!", "From: my@address.com");

PicoLisp

PicoLisp has a built-in 'mail' function. A minimal call would be 

(mail "localhost" 25 "me@from.org" "you@to.org" "Subject" NIL "Hello")

Instead of "Hello" an arbitrary number of arguments may follow (possibly containing executable expressions) for the message body.

The 6th argument (here 'NIL') may specify a list of attachments.

Pike

Untested: 

int main(){
   string to         = "some@email.add";
   string subject    = "Hello There.";
   string from       = "me@myaddr.ess";
   string msg        = "Hello there! :)";
   
   Protocols.SMTP.Client()->simple_mail(to,subject,from,msg);
}

PowerShell

PowerShell has a cmdlet named 'Send-MailMessage', and this is the easiest way to use it.

The parameters are splatted with a hashtable: 

[hashtable]$mailMessage = @{
    From = "weirdBoy@gmail.com"
    To = "anudderBoy@YourDomain.com"
    Cc = "daWaghBoss@YourDomain.com"
    Attachment = "C:\temp\Waggghhhh!_plan.txt"
    Subject = "Waggghhhh!"
    Body = "Wagggghhhhhh!"
    SMTPServer = "smtp.gmail.com"
    SMTPPort = "587"
    UseSsl = $true
    ErrorAction = "SilentlyContinue" 
}

Send-MailMessage @mailMessage

PureBasic 

InitNetwork()

CreateMail(0, "from@mydomain.com", "This is the Subject")

SetMailBody(0, "Hello   " + Chr(10) + "This is a mail !")

AddMailRecipient(0, "test@yourdomain.com", #PB_Mail_To)

AddMailRecipient(0, "test2@yourdomain.com", #PB_Mail_Cc)
    
If SendMail(0, "smtp.mail.com")
    MessageRequester("Information", "Mail correctly sent !")
Else
    MessageRequester("Error", "Can't sent the mail !")
EndIf

Python

Python: POSIX

The function returns a dict of any addresses it could not forward to; other connection problems raise errors.
Tested on Windows, it should work on all POSIX platforms. 

import smtplib

def sendemail(from_addr, to_addr_list, cc_addr_list,
              subject, message,
              login, password,
              smtpserver='smtp.gmail.com:587'):
    header  = 'From: %s\n' % from_addr
    header += 'To: %s\n' % ','.join(to_addr_list)
    header += 'Cc: %s\n' % ','.join(cc_addr_list)
    header += 'Subject: %s\n\n' % subject
    message = header + message
    
    server = smtplib.SMTP(smtpserver)
    server.starttls()
    server.login(login,password)
    problems = server.sendmail(from_addr, to_addr_list, message)
    server.quit()
    return problems

Example use: 

sendemail(from_addr    = 'python@RC.net', 
          to_addr_list = ['RC@gmail.com'],
          cc_addr_list = ['RC@xx.co.uk'], 
          subject      = 'Howdy', 
          message      = 'Howdy from a python function', 
          login        = 'pythonuser', 
          password     = 'XXXXX')
Sample Email received:
Message-ID: <4a4a1e78.0717d00a.1ba8.ffcfdbdd@xx.google.com>
Date: Tue, 30 Jun 2009 22:04:56 -0700 (PDT)
From: python@RC.net
To: RC@gmail.com
Cc: RC@xx.co.uk
Subject: Howdy

Howdy from a python function

Python: Windows

Using Outlook COM server with the Pywin32 library. 

import win32com.client

def sendmail(to, title, body):
    olMailItem = 0
    ol = win32com.client.Dispatch("Outlook.Application")
    msg = ol.CreateItem(olMailItem)
    msg.To = to
    msg.Subject = title
    msg.Body = body
    msg.Send()
    ol.Quit()

sendmail("somebody@somewhere", "Title", "Hello")

R

R does not have a built-in facility for sending emails though there is a package for this on CRAN: mail.

Windows

Using Outlook COM server with the RDCOMClient package. 

library(RDCOMClient)

send.mail <- function(to, title, body) {
  olMailItem <- 0
  ol <- COMCreate("Outlook.Application")
  msg <- ol$CreateItem(olMailItem)
  msg[["To"]] <- to
  msg[["Subject"]] <- title
  msg[["Body"]] <- body
  msg$Send()
  ol$Quit()
}

send.mail("somebody@somewhere", "Title", "Hello")

Racket

Racket has a built-in library for sending e-mails: 

#lang racket

;; using sendmail:
(require net/sendmail)
(send-mail-message
 "sender@somewhere.com" "Some Subject"
 '("recipient@elsewhere.com" "recipient2@elsewhere.com")
 '("cc@elsewhere.com")
 '("bcc@elsewhere.com")
 (list "Some lines of text" "go here."))

;; and using smtp (and adding more headers here):
(require net/head net/smtp)
(smtp-send-message 
 "192.168.0.1"
 "Sender <sender@somewhere.com>"
 '("Recipient <recipient@elsewhere.com>")
 (standard-message-header
  "Sender <sender@somewhere.com>"
  '("Recipient <recipient@elsewhere.com>")
  '() ; CC
  '() ; BCC
  "Subject")
 '("Hello World!"))

Raku

(formerly Perl 6) 

use Email::Simple;

my $to      = 'mail@example.com';
my $from    = 'me@example.com';
my $subject = 'test';
my $body    = 'This is a test.';

my $email = Email::Simple.create(
    :header[['To', $to], ['From', $from], ['Subject', $subject]],
    :body($body)
);

say ~$email;

# Note that the following will fail without an actual smtp server that
# will accept anonymous emails on port 25 (Not very common anymore).
# Most public email servers now require authentication and encryption.

my $smtp-server = 'smtp.example.com';
my $smtp-port   = 25;

await IO::Socket::Async.connect($smtp-server, $smtp-port).then(
    -> $smtp {
        if $smtp.status {
            given $smtp.result {
                react {
                    whenever .Supply() -> $response {
                        if $response ~~ /^220/ {
                            .print( join "\r\n",
                                "EHLO $smtp-server",
                                "MAIL FROM:<{$email.from}>",
                                "RCPT TO:<{$email.to}>",
                                "DATA", $email.body,
                                '.', ''
                            )
                        }
                        elsif $response ~~ /^250/ {
                            .print("QUIT\r\n");
                            done
                        }
                        else {
                           say "Send email failed with: $response";
                           done
                        }
                    }
                    .close
                }
            }
        }
    }
)

REBOL 

send user@host.dom "My message"

REXX

There is a REXX program to send email via REXX,   I'm trying to locate the author to get permission to include it here on Rosetta Code.

Ring 

load "stdlib.ring"
See "Send email..." + nl
sendemail("smtp://smtp.gmail.com",
          "calmosoft@gmail.com",
          "password",
          "calmosoft@gmail.com",
          "calmosoft@gmail.com",
          "calmosoft@gmail.com",
          "Sending email from Ring",
          "Hello
           How are you?
           Are you fine?
           Thank you!
           Greetings,
           CalmoSoft")
see "Done.." + nl

Output: 

Hello
How are you?
Are you fine?
Thank you!
Greetings,
CalmoSoft

Ruby

Uses the

Library: RubyGems

gems TMail which allows us to manipulate email objects conveniently, and mime-types which guesses a file's mime type based on its filename. 

require 'base64'
require 'net/smtp'
require 'tmail'
require 'mime/types'

class Email
  def initialize(from, to, subject, body, options={})
    @opts = {:attachments => [], :server => 'localhost'}.update(options)
    @msg = TMail::Mail.new
    @msg.from    = from
    @msg.to      = to
    @msg.subject = subject
    @msg.cc      = @opts[:cc]  if @opts[:cc]
    @msg.bcc     = @opts[:bcc] if @opts[:bcc]

    if @opts[:attachments].empty?
      # just specify the body
      @msg.body = body
    else
      # attach attachments, including the body
      @msg.body = "This is a multi-part message in MIME format.\n"

      msg_body = TMail::Mail.new
      msg_body.body = body
      msg_body.set_content_type("text","plain", {:charset => "ISO-8859-1"})
      @msg.parts << msg_body

      octet_stream = MIME::Types['application/octet-stream'].first

      @opts[:attachments].select {|file| File.readable?(file)}.each do |file|
        mime_type = MIME::Types.type_for(file).first || octet_stream
        @msg.parts << create_attachment(file, mime_type)
      end
    end
  end
  attr_reader :msg

  def create_attachment(file, mime_type)
    attach = TMail::Mail.new
    if mime_type.binary?
      attach.body = Base64.encode64(File.read(file))
      attach.transfer_encoding = 'base64'
    else
      attach.body = File.read(file)
    end
    attach.set_disposition("attachment", {:filename => file})
    attach.set_content_type(mime_type.media_type, mime_type.sub_type, {:name=>file})
    attach
  end

  # instance method to send an Email object
  def send
    args = @opts.values_at(:server, :port, :helo, :username, :password, :authtype)
    Net::SMTP.start(*args) do |smtp|
      smtp.send_message(@msg.to_s, @msg.from[0], @msg.to)
    end
  end

  # class method to construct an Email object and send it
  def self.send(*args)
    self.new(*args).send
  end
end

Email.send(
  'sender@sender.invalid',
  %w{ recip1@recipient.invalid recip2@example.com },
  'the subject',
  "the body\nhas lines",
  {
    :attachments => %w{ file1 file2 file3 },
    :server => 'mail.example.com',
    :helo => 'sender.invalid',
    :username => 'user',
    :password => 'secret'
  }
)

SAS 

filename msg email
   to="afriend@someserver.com"
   cc="anotherfriend@somecompany.com"
   subject="Important message"
;

data _null_;
   file msg;
   put "Hello, Connected World!";
run;

Scala

Library: Scala
import java.util.Properties

import javax.mail.internet.{ InternetAddress, MimeMessage }
import javax.mail.Message.RecipientType
import javax.mail.{ Session, Transport }

/** Mail constructor.
 *  @constructor Mail
 *  @param host Host
 */
class Mail(host: String) {
  val session = Session.getDefaultInstance(new Properties() { put("mail.smtp.host", host) })

  /** Send email message.
   *
   *  @param from From
   *  @param tos Recipients
   *  @param ccs CC Recipients
   *  @param subject Subject
   *  @param text Text
   *  @throws MessagingException
   */
  def send(from: String, tos: List[String], ccs: List[String], subject: String, text: String) {
    val message = new MimeMessage(session)
    message.setFrom(new InternetAddress(from))
    for (to <- tos)
      message.addRecipient(RecipientType.TO, new InternetAddress(to))
    for (cc <- ccs)
      message.addRecipient(RecipientType.TO, new InternetAddress(cc))
    message.setSubject(subject)
    message.setText(text)
    Transport.send(message)
  }
}

SQL PL

Works with: Db2 LUW

version 9.7 or higher.

With SQL PL: You must first set the SMTP server in the database from which you want to send the message. 

UPDATE DB CFG FOR myDb USING SMTP_SERVER 'smtp.ibm.com';

CALL UTL_MAIL.SEND ('senderAccount@myDomain.com','recipientAccount@yourDomain.com', 'copy@anotherDomain.com', NULL, 'The subject of the message', 'The content of the message');

Output: 

db2 => UPDATE DB CFG FOR myDb USING SMTP_SERVER 'smtp.ibm.com';
DB20000I  The UPDATE DATABASE CONFIGURATION command completed successfully.
db2 => CALL UTL_MAIL.SEND ('senderAccount@myDomain.com','recipientAccount@yourDomain.com', NULL, NULL, 'The subject of the message', 'The content of the message');

  Return Status = 0

If you receive a "SQL1336N The remote host "smtp.ibm.com" was not found. SQLSTATE=08001" message, it is because the SMTP_SERVER is not valid. More information in the IBM Knowledge center

Tcl

Library: Tcllib (Package: mime)
Library: Tcllib (Package: smtp)

Also may use the tls package (needed for sending via gmail). 

package require smtp
package require mime
package require tls

set gmailUser *******
set gmailPass hunter2; # Hello, bash.org!

proc send_simple_message {recipient subject body} {
    global gmailUser gmailPass

    # Build the message
    set token [mime::initialize -canonical text/plain -string $body]
    mime::setheader $token Subject $subject

    # Send it!
    smtp::sendmessage $token -userame $gamilUser -password $gmailPass \
            -recipients $recipient -servers smtp.gmail.com -ports 587

    # Clean up
    mime::finalize $token
}

send_simple_message recipient@example.com "Testing" "This is a test message."

TUSCRIPT

works only with Windows, on Linux OS it is possible to send an email by using the Execute function 

$$ MODE TUSCRIPT

system=SYSTEM ()

IF (system=="WIN") THEN
SET to="name@domain.org"
SET cc="name@domain.net"
subject="test"
text=*
DATA how are you?

status = SEND_MAIL (to,cc,subject,text,-)

ENDIF

TXR 

#!/usr/bin/txr
@(next :args)
@(cases)
@TO
@SUBJ
@  (maybe)
@CC
@  (or)
@  (bind CC "")
@  (end)
@(or)
@  (throw error "must specify at least To and Subject")
@(end)
@(next *stdin*)
@(collect)
@BODY
@(end)
@(output (open-command `mail -s "@SUBJ" -a CC: "@CC" "@TO"` "w"))
@(repeat)
@BODY
@(end)
.
@(end)
Output:
$ ./sendmail.txr linux-kernel@vger.kernel.org "Patch to rewrite scheduler #378"
Here we go
again ...
[Ctrl-D]
$

VBA 

Option Explicit
Const olMailItem = 0

Sub SendMail(MsgTo As String, MsgTitle As String, MsgBody As String)
    Dim OutlookApp As Object, Msg As Object
    Set OutlookApp = CreateObject("Outlook.Application")
    Set Msg = OutlookApp.CreateItem(olMailItem)
    With Msg
        .To = MsgTo
        .Subject = MsgTitle
        .Body = MsgBody
        .Send
    End With
    Set OutlookApp = Nothing
End Sub

Sub Test()
    SendMail "somebody@somewhere", "Title", "Hello"
End Sub

VBScript 

Function send_mail(from,recipient,cc,subject,message)
	With CreateObject("CDO.Message")
		.From = from
		.To = recipient
		.CC = cc
		.Subject = subject
		.Textbody = message
		.Configuration.Fields.Item _
			("http://schemas.microsoft.com/cdo/configuration/sendusing") = 2
		.Configuration.Fields.Item _
			("http://schemas.microsoft.com/cdo/configuration/smtpserver") = _
		        "mystmpserver"
		.Configuration.Fields.Item _
		    ("http://schemas.microsoft.com/cdo/configuration/smtpserverport") = 25
		.Configuration.Fields.Update
		.Send
	End With
End Function

Call send_mail("Alerts@alerts.org","jkspeed@jkspeed.org","","Test Email","this is a test message")

Wren

Translation of: Go
Library: WrenGo

An embedded application with a Go host so we can use their net/smtp module. 

/* Send_email.wren */

foreign class Authority {
    construct plainAuth(identity, username, password, host) {}
}

class SMTP {
    foreign static sendMail(address, auth, from, to, msg)
}

class Message {
    static check(host, user, pass) {
        if (host == "") Fiber.abort("Bad host")
        if (user == "") Fiber.abort("Bad username")
        if (pass == "") Fiber.abort("Bad password")
    }

    construct new(from, to, cc, subject, content) {
        _from = from
        _to = to
        _cc = cc
        _subject = subject
        _content = content
    }

    toString {
        var to = _to.join(",")
        var cc = _cc.join(",")
        var s1 = "From: " + _from + "\n"
        var s2 = "To: " + to + "\n"
        var s3 = "Cc: " + cc + "\n"
        var s4 = "Subject: " + _subject + "\n\n"
        return s1 + s2 + s3 + s4 + _content
    }

    send(host, port, user, pass) {
        Message.check(host, user, pass)
        SMTP.sendMail(
            "%(host):%(port)",
            Authority.plainAuth("", user, pass, host),
            _from,
            _to,
            toString
        )
    }
}

foreign class Reader {
    construct new() {}

    foreign readString(delim)
}

var host = "smtp.gmail.com"
var port = 587
var user = "some.user@gmail.com"
var pass = "secret"

var bufin = Reader.new()
var NL = 10

System.write("From: ")
var from = bufin.readString(NL).trim()

var to = []
while (true) {
    System.write("To (Blank to finish): ")
    var tmp = bufin.readString(NL).trim()
    if (tmp == "") break
    to.add(tmp)
}

var cc = []
while (true) {
    System.write("Cc (Blank to finish): ")
    var tmp = bufin.readString(NL).trim()
    if (tmp == "") break
    cc.add(tmp)
}

System.write("Subject: ")
var subject = bufin.readString(NL).trim()

var contentLines = []
while (true) {
    System.write("Content line (Blank to finish): ")
    var line = bufin.readString(NL).trim()
    if (line == "") break
    contentLines.add(line)
}
var content = contentLines.join("\r\n")

var m = Message.new(from, to, cc, subject, content)
System.print("\nSending message...")
m.send(host, port, user, pass)
System.print("Message sent.")


We now embed this script in the following Go program and run it. 

/* go run Send_email.go */

package main

import(
    wren "github.com/crazyinfin8/WrenGo"
    "log"
    "bufio"
    "net/smtp"
    "os"
)

type any = interface{}

func sendMail(vm *wren.VM, parameters []any) (any, error) {
    address := parameters[1].(string)
    handle  := parameters[2].(*wren.ForeignHandle)
    ifc, _  := handle.Get()
    auth    := ifc.(*smtp.Auth)
    from    := parameters[3].(string)
    handle2 := parameters[4].(*wren.ListHandle)
    le, _   := handle2.Count()
    to      := make([]string, le)
    for i := 0; i < le; i++ {
        ifc2, _ := handle2.Get(i)
        to[i] = ifc2.(string)
    }
    msg := parameters[5].(string)
    err := smtp.SendMail(address, *auth, from, to, []byte(msg))
    if err != nil {
        log.Fatal(err)
    }
    return nil, nil
}

func plainAuth(vm *wren.VM, parameters []any) (any, error) {
    identity := parameters[1].(string)
    username := parameters[2].(string)
    password := parameters[3].(string)
    host     := parameters[4].(string)
    auth     := smtp.PlainAuth(identity, username, password, host)
    return &auth, nil
}

func newReader(vm *wren.VM, parameters []any) (any, error) {
    reader := bufio.NewReader(os.Stdin)
    return &reader, nil
}

func readString(vm *wren.VM, parameters []any) (any, error) {
    handle := parameters[0].(*wren.ForeignHandle)
    ifc, _ := handle.Get()
    bufin := ifc.(**bufio.Reader)
    delim := byte(parameters[1].(float64))
    s, _ := (*bufin).ReadString(delim)
    return s, nil
}

func main() {
    vm := wren.NewVM()
    fileName := "Send_email.wren"

    smtpMethodMap   := wren.MethodMap { "static sendMail(_,_,_,_,_)": sendMail }
    readerMethodMap := wren.MethodMap { "readString(_)": readString }

    classMap := wren.ClassMap {
        "Authority": wren.NewClass(plainAuth, nil, nil),
        "SMTP"     : wren.NewClass(nil, nil, smtpMethodMap),
        "Reader"   : wren.NewClass(newReader, nil, readerMethodMap),
    }

    module := wren.NewModule(classMap)
    vm.SetModule(fileName, module)
    vm.InterpretFile(fileName)
    vm.Free()
}
Retrieved from "https://rosettacode.org/wiki/Send_email?oldid=362773"