Send email: Difference between revisions

=={{header|Ada}}==

{{libheader|AWS}}

with Ada.Text_IO;

use Ada, AWS;

end if;

end Sendmail;

=={{header|AutoHotkey}}==

ahk [http://www.autohotkey.com%2Fforum%2Ftopic39797.html discussion]

{{libheader | COM.ahk}}

sText := "hello"

sFrom := "ahk@rosettacode"

COM_Release(pmsg)

COM_Term()

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

Server$ = "smtp.gmail.com"

WHILE FN_readlinesocket(skt%, 10, reply$) > 0 : ENDWHILE

ENDPROC

=={{header|C}}==

Sends mail via the GMail SMTP server, requires [https://curl.haxx.se/libcurl/ libcurl]

{{libheader|libcurl}}

#include <curl/curl.h>

return (int)res;

}

=={{header|C sharp|C#}}==

{{works with|Mono|1.2}}

{{works with|Visual C sharp|Visual C#|2003}}

static void Main(string[] args)

{

Console.WriteLine("Message Sent");

}

=={{header|C++}}==

{{works with|POCO|1.3.6}}

// or see http://pocoproject.org/

// compile with: g++ -Wall -O3 send-mail-cxx.C -lPocoNet -lPocoFoundation

return EXIT_SUCCESS;

When run literally as above, should print:

[https://github.com/drewr/postal Postal] wraps JavaMail to make sending emails simple and platform independent.

(send-message {:host "smtp.gmail.com"

:cc ["bob@builder.com" "dora@explorer.com"]

:subject "Yo"

{{out}}

=={{header|D}}==

Requires the libcurl library to be installed on the system.

import std.net.curl;

s.message = "Subject:test\n\nExample Message";

s.perform;

=={{header|Delphi}}==

procedure SendEmail;

var

end;

end;

=={{header|Diego}}==

This <code>instruct</code>ion instructs a thing in the mist to send an email. It understands that the found <code>thing</code> 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.

set_thread(linger);

find_thing()_first()_email()

_me();

=={{header|Emacs Lisp}}==

Variable <code>send-mail-function</code> 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 (<code>sendmail</code>, SMTP, etc). The default queries the user for initial setup.

(with-temp-buffer

(insert "From: " from "\n"

(my-send-email "from@example.com" "to@example.com" ""

"very important"

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

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

"my.gmail.address@gmail.com" "qwertyuiasdfghjk" <plain-auth>

>>auth \ smtp-config set-global <email> f >>from t >>to

=={{header|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

}

}

=={{header|Fortran}}==

Using Outlook COM server. Before compiling the program, it's necessary to use the '''[https://software.intel.com/en-us/node/535422 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).

use ifcom

use msoutl

call $Application_Quit(app, status)

call comuninitialize()

=={{header|Go}}==

Supports TLS connections.

import (

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

=={{header|Groovy}}==

From [http://www.jedox.com/en/send-email-using-javamail-groovy-script/] we can get email solution for Groovy

import javax.mail.*

import javax.mail.internet.*

/*Call function */

simpleMail(s1, s2 , s3, "TITLE", "TEXT");

=={{header|Haskell}}==

Example using [https://hackage.haskell.org/package/smtp-mail <tt>smtp-mail</tt>] package:

module Main (main) where

[ plainTextPart "This is plain text."

, htmlPart "<h1>Title</h1><p>This is HTML.</p>"

==Icon and {{header|Unicon}}==

A Unicon-specific solution is:

mail := open("mailto:"||args[1], "m", "Subject : "||args[2],

"X-Note: automatically send by Unicon") |

every write(mail , !&input)

close (mail)

=={{header|Java}}==

import javax.mail.MessagingException;

Transport.send(message);

}

=={{header|Julia}}==

using SMTPClient

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")

=={{header|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.

import java.util.Properties

val password = "secret"

sendEmail(user, tos, ccs, title, body, password)

=={{header|Lasso}}==

This example leverages Lasso's built in Email_Send method.

// sends plain text and html in same email

// simple usage is below

-body = 'Lasso is awesome, you should try it!'

)

=={{header|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."

end

=={{header|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.

{{libheader|Shell Xtra}}

-- Sends email via SMTP using senditquiet.exe (15 KB)

-- @param {string} fromAddr

res = sx.shell_cmd(cmd)

return not(res contains "ERROR")

=={{header|LiveCode}}==

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

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

=={{header|LotusScript}}==

Dim db As NotesDatabase

Dim doc As NotesDocument

doc.SendTo = "John Doe"

doc.Subject = "Subject of this mail"

=={{header|Lua}}==

Using [http://w3.impa.br/~diego/software/luasocket/smtp.html LuaSocket's SMTP module] (from the documentation on that page):

local smtp = require("socket.smtp")

source = smtp.message(mesgt)

}

=={{header|Mathematica}}/{{header|Wolfram Language}}==

Mathematica has the built-in function SendMail, example:

"Subject" -> "Sending Email from Mathematica", "Body" -> "Hello world!",

The following options can be specified:

"Cc"

"Bcc"

"ReplyTo"

"ServerAuthentication"

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.

=={{header|NewLISP}}==

* using library smtp.lsp

=={{header|Nim}}==

Compile with <code>nim c -d:ssl mail</code>

proc sendMail(fromAddr: string; toAddrs, ccAddrs: seq[string];

message = "Nim says hi!\nAnd bye again!",

login = "nim@gmail.com",

=={{header|OCaml}}==

* using the library [http://www.linux-nantes.org/~fmonnier/OCaml/smtp-mail/ smtp-mail-0.1.3]

Smtp.helo h "hostname";;

Smtp.mail h "<john.smith@example.com>";;

let email_msg = "Happy Birthday";;

Smtp.data h (email_header ^ "\r\n\r\n" ^ email_msg);;

=={{header|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 Authen::SASL;

# Net::SMTP's 'auth' method needs Authen::SASL to work, but

$smtp->dataend;

An example call:

from => 'A. T. Tappman',

to => ['suchandsuch@example.com', 'soandso@example.org'],

host => 'smtp.example.com:587',

user => 'tappman@example.com',

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

to => 'suchandsuch@example.com',

{{libheader|LWP}}

LWP can send email by a POST to a <code>mailto:</code> 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 <code>sendmail</code> program, or on MacOS classic by SMTP (to <code>SMTPHOSTS</code> environment variable). For reference, the <code>$ua-&gt;post()</code> method does not suit since it constructs a message as MIME "form data".

use LWP::UserAgent;

use HTTP::Request;

send_email('from-me@example.com', 'to-foo@example.com', '',

"very important subject",

=={{header|Phix}}==

Obviously, USER/PWD/URL/etc. would all need altering for your details.

For gmail, make sure you enable https://myaccount.google.com/lesssecureapps

<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- (libcurl)</span>

<span style="color: #008080;">include</span> <span style="color: #000000;">builtins</span><span style="color: #0000FF;">\</span><span style="color: #000000;">libcurl</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>

<span style="color: #7060A8;">curl_easy_cleanup</span><span style="color: #0000FF;">(</span><span style="color: #000000;">curl</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">curl_global_cleanup</span><span style="color: #0000FF;">()</span>

=={{header|PHP}}==

=={{header|PicoLisp}}==

PicoLisp has a built-in '[http://software-lab.de/doc/refM.html#mail mail]'

function. A minimal call would be

Instead of "Hello" an arbitrary number of arguments may follow (possibly

containing executable expressions) for the message body.

Untested:

string to = "some@email.add";

string subject = "Hello There.";

Protocols.SMTP.Client()->simple_mail(to,subject,from,msg);

=={{header|PowerShell}}==

The parameters are splatted with a hashtable:

[hashtable]$mailMessage = @{

From = "weirdBoy@gmail.com"

Send-MailMessage @mailMessage

=={{header|PureBasic}}==

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

Else

MessageRequester("Error", "Can't sent the mail !")

=={{header|Python}}==

Tested on Windows, it should work on all [[wp:POSIX|POSIX]] platforms.

def sendemail(from_addr, to_addr_list, cc_addr_list,

problems = server.sendmail(from_addr, to_addr_list, message)

server.quit()

Example use:

to_addr_list = ['RC@gmail.com'],

cc_addr_list = ['RC@xx.co.uk'],

message = 'Howdy from a python function',

login = 'pythonuser',

{{out|Sample Email received}}

Using Outlook COM server with the Pywin32 library.

def sendmail(to, title, body):

ol.Quit()

=={{header|R}}==

Using Outlook COM server with the '''[http://www.omegahat.net/RDCOMClient/ RDCOMClient]''' package.

send.mail <- function(to, title, body) {

}

=={{header|Racket}}==

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

#lang racket

"Subject")

'("Hello World!"))

=={{header|Raku}}==

(formerly Perl 6)

my $to = 'mail@example.com';

}

}

=={{header|REBOL}}==

=={{header|REXX}}==

=={{header|Ring}}==

load "stdlib.ring"

See "Send email..." + nl

CalmoSoft")

see "Done.." + nl

Output:

<pre>

Uses the {{libheader|RubyGems}} gems [http://tmail.rubyforge.org TMail] which allows us to manipulate email objects conveniently, and [http://mime-types.rubyforge.org/ mime-types] which guesses a file's mime type based on its filename.

require 'net/smtp'

require 'tmail'

:password => 'secret'

}

=={{header|SAS}}==

to="afriend@someserver.com"

cc="anotherfriend@somecompany.com"

file msg;

put "Hello, Connected World!";

=={{header|Scala}}==

{{libheader|Scala}}

import javax.mail.internet.{ InternetAddress, MimeMessage }

Transport.send(message)

}

=={{header|SQL PL}}==

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:

<pre>

{{tcllib|mime}}{{tcllib|smtp}}

Also may use the [http://tls.sourceforge.net/ tls] package (needed for sending via gmail).

package require mime

package require tls

}

=={{header|TUSCRIPT}}==

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

$$ MODE TUSCRIPT

ENDIF

=={{header|TXR}}==

@(next :args)

@(cases)

@(end)

.

{{out}}

=={{header|VBA}}==

Const olMailItem = 0

Sub Test()

SendMail "somebody@somewhere", "Title", "Hello"

=={{header|VBScript}}==

Function send_mail(from,recipient,cc,subject,message)

With CreateObject("CDO.Message")

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

=={{header|Wren}}==

{{libheader|WrenGo}}

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

foreign class Authority {

System.print("\nSending message...")

m.send(host, port, user, pass)

<br>

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

package main

vm.InterpretFile(fileName)

vm.Free()