Send email: Difference between revisions
(adding SAS) |
|||
Line 628: | Line 628: | ||
my $smtp = new Net::SMTP($o{host} ? $o{host} : ()) |
my $smtp = new Net::SMTP($o{host} ? $o{host} : ()) |
||
or die |
or die "Couldn't connect to SMTP server"; |
||
$o{password} and |
$o{password} and |
||
Line 651: | Line 651: | ||
from => 'A. T. Tappman', |
from => 'A. T. Tappman', |
||
to => ['suchandsuch@example.com', 'soandso@example.org'], |
to => ['suchandsuch@example.com', 'soandso@example.org'], |
||
cc => somebodyelse@example.net', |
cc => 'somebodyelse@example.net', |
||
subject => 'Important message', |
subject => 'Important message', |
||
body => 'I yearn for you tragically.', |
body => 'I yearn for you tragically.', |
Revision as of 02:25, 19 February 2012
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)
Ada
<lang Ada>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; </lang>
AutoHotkey
ahk discussion
<lang autohotkey>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</lang>
BBC BASIC
<lang bbcbasic> 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
</lang>
Delphi
<lang 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; </lang>
Factor
This one uses the build-in SMTP vocabulary. Note that 'to' and 'cc' need to be arrays of strings containing an email address.
<lang Factor> 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 ;</lang>
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.
<lang fantom> 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) }
} </lang>
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.
<lang go>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") }</lang>
Java
<lang java5>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); }
}</lang>
Liberty BASIC
This program requires sendemail.exe and sendemail.pl in the same directory, available free from Caspian's SendEmail Site. <lang lb> 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 </lang>
LotusScript
<lang 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 )</lang>
Lua
Using LuaSocket's SMTP module (from the documentation on that page):
<lang Lua>-- 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)
} </lang>
Mathematica
Mathematica has the built-in function SendMail, example: <lang Mathematica>SendMail["From" -> "from@email.com", "To" -> "to@email.com",
"Subject" -> "Sending Email from Mathematica", "Body" -> "Hello world!", "Server" -> "smtp.email.com"]</lang>
The following options can be specified: <lang Mathematica>"To" "Cc" "Bcc" "Subject" "Body" "Attachments" "From" "Server" "EncryptionProtocol" "Fullname" "Password" "PortNumber" "ReplyTo" "ServerAuthentication" "UserName"</lang> 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
<lang NewLISP>(module "smtp.lsp") (SMTP:send-mail "user@asite.com" "somebody@isp.com" "Greetings" "How are you today? - john doe -" "smtp.asite.com" "user" "password")</lang>
OCaml
- using the library smtp-mail-0.1.3
<lang 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;;</lang>
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.
<lang perl>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;}</lang>
An example call:
<lang perl>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';</lang>
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:
<lang perl>send_email
to => 'suchandsuch@example.com', user => 'tappman@example.com';</lang>
PHP
<lang php>mail('hello@world.net', 'My Subject', "A Message!", "From: my@address.com");</lang>
PicoLisp
PicoLisp has a built-in 'mail' function. A minimal call would be <lang PicoLisp>(mail "localhost" 25 "me@from.org" "you@to.org" "Subject" NIL "Hello")</lang> 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:
<lang pike>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);
}</lang>
PureBasic
<lang 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</lang>
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.
<lang python>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</lang>
Example use: <lang python>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')</lang>
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
R
R does not have a built-in facility for sending emails though some code for this, written by Ben Bolker, is available here.
REBOL
<lang rebol>send user@host.dom "My message"</lang>
Ruby
Uses the
gems TMail which allows us to manipulate email objects conveniently, and mime-types which guesses a file's mime type based on its filename.
<lang ruby>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' }
)</lang>
SAS
<lang sas>filename msg email
to="afriend@someserver.com" cc="anotherfriend@somecompany.com" subject="Important message"
data _null_;
file msg; put "Hello, Connected World!";
run;</lang>
Tcl
Also may use the tls package (needed for sending via gmail). <lang tcl>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."</lang>
TUSCRIPT
works only with Windows, on Linux OS it is possible to send an email by using the Execute function <lang tuscript> $$ 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 </lang>
TXR
<lang 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) </lang>
Test run:
$ ./sendmail.txr linux-kernel@vger.kernel.org "Patch to rewrite scheduler #378" Here we go again ... [Ctrl-D] $
- Programming Tasks
- Networking and Web Interaction
- Ada
- AWS
- AutoHotkey
- COM.ahk
- BBC BASIC
- Delphi
- Factor
- Fantom
- Go
- Java
- Liberty BASIC
- LotusScript
- Lua
- Mathematica
- NewLISP
- OCaml
- Perl
- PHP
- PicoLisp
- Pike
- PureBasic
- Python
- R
- Tcltk
- Gdata
- CaTools
- REBOL
- Ruby
- RubyGems
- SAS
- Tcl
- Tcllib
- TUSCRIPT
- ML/I/Omit
- Openscad/Omit
- PARI/GP/Omit
- Retro/Omit
- TI-83 BASIC/Omit
- TI-89 BASIC/Omit
- JavaScript/Omit
- Yorick/Omit
- ZX Spectrum Basic/Omit
- TXR