Policy change. Edit privileges will now require email addresses to be confirmed. (Details) --Michael Mol 14:53, 14 March 2012 (UTC)

Send email

From Rosetta Code
Jump to: navigation, search
Task
Send email
You are encouraged to solve this task according to the task description, using any language you may know.
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)

Contents

[edit] 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;
 

[edit] 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

[edit] 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
 

[edit] 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;
 

[edit] 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: kernel accessors smtp io.sockets namespaces ;
IN: learn
 
: send-mail ( from to cc subject body -- )
    "smtp.gmail.com" 587 <inet> smtp-server set
    smtp-tls? on
    "noneofyourbuisness@gmail.com" "password" <plain-auth> smtp-auth set
    <email>
        swap >>from
        swap >>to
        swap >>cc
        swap >>subject
        swap >>body
    send-email ;

[edit] 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)
  }
}
 

[edit] 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")
}

[edit] 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);
 }
}

[edit] 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
 


[edit] 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 )

[edit] 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)
}
 

[edit] Mathematica

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.


[edit] 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")

[edit] 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;;

[edit] Perl

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 = new Net::SMTP($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';

[edit] PHP

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

[edit] 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.

[edit] 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);
}

[edit] 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

[edit] Python

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

[edit] R

Library: tcltk
Library: gdata
Library: caTools

R does not have a built-in facility for sending emails though some code for this, written by Ben Bolker, is available here.

[edit] REBOL

send user@host.dom "My message"

[edit] 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'
  }
)

[edit] SAS

filename msg email
   to="afriend@someserver.com"
   cc="anotherfriend@somecompany.com"
   subject="Important message"
;
 
data _null_;
   file msg;
   put "Hello, Connected World!";
run;

[edit] 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."

[edit] 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
 

[edit] 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 "-")
@(collect)
@BODY
@(end)
@(output `!mail -s "@SUBJ" -c "@CC" "@TO"`)
@(repeat)
@BODY
@(end)
.
@(end)
 

Test run: 

$ ./sendmail.txr linux-kernel@vger.kernel.org "Patch to rewrite scheduler #378"
Here we go
again ...
[Ctrl-D]
$
Retrieved from "http://rosettacode.org/mw/index.php?title=Send_email&oldid=132506"
Personal tools
Namespaces
Variants
Actions
Community/News
Browse wiki
Misc
Toolbox