---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
` value to it.
>
> The default is TLSv1. If you need to change the connection type, close the connection first.
>
> This example changes the connection type to TLSv1.
>
> ``` xojo
> SMTPSecureSocket1.SSLConnectionType = SSLSocket.SSLConnectionTypes.TLSv1
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SMTPSecureSocket.SSLEnabled
**SSLEnabled** As `Boolean`
> Set to `True` to specify an SSL connection.
>
> If SSLEnabled is `False`, the **SSLSocket** transmits data just like a `TCPSocket`. This property can be toggled at any time.
>
> ``` xojo
> Me.SSLEnabled = True
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SMTPSecureSocket.Username
**Username** As `String`
> The Username to use to log into the SMTP server.
## Method descriptions
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SMTPSecureSocket.Close
**Close**
> Closes the socket's connection, closes any connections the socket may have, and resets the socket.
>
> The only information that is retained after calling Close is the socket's port, address (in the case of `TCPSockets`), and data left in the socket's receive buffer. All other information is discarded.
>
> This example closes the `EasyTCPSockets` that were open. The sockets were added to the main window.
>
> ``` xojo
> Connector.Close
> Listener.Close
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SMTPSecureSocket.Connect
**Connect**
> Attempts to connect.
>
> For `TCPSockets`, the address and port properties must be set. For `UDPSockets`, the port property must be set. The Connect method binds a socket to a port. After calling Connect, the Port property will report the actual port you are bound to.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SMTPSecureSocket.Disconnect
**Disconnect**
> Disconnects the socket, resets it, and fires a `SocketCore` Error event with a 102 error to let you know that the socket has been disconnected.
>
> This example disconnects the `EasyTCPSockets` that were opened.
>
> ``` xojo
> Connector.Disconnect
> Listener.Disconnect
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SMTPSecureSocket.DisconnectFromServer
**DisconnectFromServer**
> Closes the connection with the mail server.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SMTPSecureSocket.EndOfFile
**EndOfFile** As `Boolean`
> Returns `True` when there's no more data left to read.
>
> This code reads the rows and columns of data from a tab-delimited text file into a `ListBox`:
>
> ``` xojo
> Var f As FolderItem = FolderItem.ShowOpenFileDialog("text/plain") ' defined as a FileType
>
> If f <> Nil Then
>
> Var textInput As TextInputStream
> Var rowFromFile, oneCell As String
>
> textInput = TextInputStream.Open(f)
> textInput.Encoding = Encodings.UTF8
>
> Do
>
> rowFromFile = textInput.ReadLine
>
> Var values() As String = rowFromFile.ToArray(String.Chr(9))
>
> ListBox1.ColumnCount = values.Count
> ListBox1.AddRow("")
>
> Var col As Integer
>
> For Each value As String In values
>
> ListBox1.CellTextAt(ListBox1.LastAddedRowIndex, col) = value
> col = col + 1
>
> End For
>
> Loop Until textInput.EndOfFile
>
> textInput.Close
>
> End If
> ```
>
> This example reads each pair of bytes from a file and writes them in reverse order to a new file. The user chooses the source file using the Open-file dialog box and saves the new file using the Save as dialog box. The EOF property is used to terminate the `Do...Loop`.
>
> ``` xojo
> Var readFile As FolderItem = FolderItem.ShowOpenFileDialog("text")
>
> If readFile <> Nil Then
>
> Var ReadStream As BinaryStream = BinaryStream.Open(readFile, False)
> Var writeFile As FolderItem = FolderItem.ShowSaveFileDialog("", "")
>
> ReadStream.LittleEndian = True
>
> If writeFile <> Nil Then
>
> Var writeStream As BinaryStream = BinaryStream.Create(writeFile, True)
>
> writeStream.LittleEndian = True
>
> Do Until ReadStream.EndOfFile
> writeStream.WriteInt8(ReadStream.ReadInt8)
> Loop
>
> writeStream = Nil
>
> End If
>
> readStream = Nil
> ```
>
> End If
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SMTPSecureSocket.Flush
**Flush**
> Immediately sends the contents of internal write buffers to disk or to the output stream.
>
> This function can be useful in point-to-point communication over sockets and similar connections: To optimize for transmission performance, some types of output streams try to collect small pieces of written data into one larger piece for sending instead of sending each piece out individually. By calling Flush, the data collection is stopped and the data is sent without further delay, reducing latency.
>
> When using this on a stream that ends up as a file on disk, it is useful, too: Any short parts of previously written data are written to disk right away, ensuring the data is actually on disk if the application terminates abruptly, e.g. due to a crash.
>
> Avoid calling this method too often. For example, do not call it between successive Write calls because you'll slow down performance without getting much benefit.
>
> A typical use case would look like this:
>
> ``` xojo
> mySocket.Write("you typed: ")
> mySocket.Write(key)
> mySocket.Write(".")
> mySocket.Flush
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SMTPSecureSocket.Listen
**Listen**
> Attempts to listen for incoming connections on the currently specified port.
>
> After calling Listen, the Port property will report the actual port you are bound to.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SMTPSecureSocket.Lookahead
**Lookahead**(Encoding As `TextEncoding` = `Nil`) As `String`
> Returns a `String`, containing the data that is available in the internal queue without removing it.
>
> The optional *Encoding* parameter enables you to specify the text encoding of the data to be returned. The default is `Nil`. Use the `Encodings` module to specify an encoding.
>
> This example adds the contents of the internal queue to a `TextArea`. The Listener `EasyTCPSocket` has been added to the window.
>
> ``` xojo
> TextArea1.AddText(listener.Lookahead)
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SMTPSecureSocket.Poll
**Poll**
> Polls the socket manually, which allows a socket to be used synchronously.
>
> The following example polls the SMTPSecureSocket.
>
> ``` xojo
> Listener.Poll
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SMTPSecureSocket.Purge
**Purge**
> Removes all data from the socket's internal receive buffer. It does not affect the socket's internal send buffer.
>
> ``` xojo
> Listener.Purge
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SMTPSecureSocket.Read
**Read**(Bytes As `Integer`, Encoding As `TextEncoding` = `Nil`) As `String`
> Reads *Bytes* bytes from the input stream and returns a `String`.
>
> If provided, the optional parameter *Encoding* specifies the text encoding to be defined for the `String` to be read.
>
> If *Bytes* is higher than the amount of bytes currently available in the stream, all available bytes will be returned. Therefore, make sure to always consider the case that you get less than you requested. To see if you received all requested bytes, check the returned string's `String` property (avoid using `Length` as it may give a different number if the encoding is not nil).
>
> If not enough memory is available, you get back an empty string.
>
> This example reads the first 1000 bytes from a `BinaryStream`.
>
> ``` xojo
> Var readFile As FolderItem = FolderItem.ShowOpenFileDialog("text/plain")
>
> If readFile <> Nil Then
>
> Var ReadStream As BinaryStream = BinaryStream.Open(readFile, False)
>
> ReadStream.LittleEndian = True
> TextArea1.Text = ReadStream.Read(1000, Encodings.UTF8)
>
> End If
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SMTPSecureSocket.ReadAll
**ReadAll**(Encoding As `TextEncoding` = `Nil`) As `String`
> Reads all the data from the internal buffer.
>
> This example reads all the data in the buffer into a `TextArea`.
>
> ``` xojo
> TextField1.AddText(listener.ReadAll)
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SMTPSecureSocket.ReadError
**ReadError** As `Boolean`
> If `True` then an error occurred during reading.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SMTPSecureSocket.RemoveAllMessages
**RemoveAllMessages**
> Removes all messages from the send queue.
>
> This example removes all the messages in the queue.
>
> ``` xojo
> SMTPSecureSocket1.RemoveAllMessages
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SMTPSecureSocket.SendMail
**SendMail**
> Connects to the mail server, sends the messages in the queue, and disconnects. SendMail is asynchronous.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SMTPSecureSocket.Write
**Write**(Data As `String`)
> Writes the passed data to the output stream.
>
> Note that in order to make sure that the data actually ends up on disk or gets sent to the socket it is connected to, the stream must either get closed or the `Flush` method be called. Otherwise, the data, if small, may end up temporarily in a write buffer before either a certain time has passed or more data is written. This buffering increases performance when writing lots of small pieces of data, but may be causing unwanted delays when another process, e.g. the other end of a socket connection, is waiting for the data. Consider calling the `Flush` method to reduce latencies that this buffering may cause in such cases.
>
> If Write fails, an `IOException` will be raised.
>
> This example displays the Save As dialog box and writes the contents of the TextArea1 to a text file.
>
> ``` xojo
> Var f As FolderItem = FolderItem.ShowSaveFileDialog(FileTypes1.Text, "Untitled.txt")
>
> If f <> Nil Then
>
> Var stream As BinaryStream
>
> stream = BinaryStream.Create(f, True)
> stream.Write(TextArea1.Text)
> stream.Close
>
> End If
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SMTPSecureSocket.WriteError
**WriteError** As `Boolean`
> If `True` then an error occurred during writing.
## Event descriptions
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SMTPSecureSocket.ConnectionEstablished
**ConnectionEstablished**(greeting As `String`)
> Executes when the connection has been established with the mail server and passes the greeting string that the server returned.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SMTPSecureSocket.Error
**Error**(e As `RuntimeException`)
> Occurs when an error occurs with the socket.
>
> These error codes provide you with key information about your socket, and it is not advisable to ignore them.
>
> When an error occurs, the `RuntimeException` property will likely contain one of the following error codes:
>
> | Error Code | Description |
> |------------|--------------------------------------------------------------------------------------------------------------------------------------------------------|
> | 0 | No error occurred. |
> | 100 | There was an error opening and initializing the drivers. |
> | 101 | This error code is no longer used. |
> | 102 | This code means that you lost your connection. If the remote side closed the connection, then it is not truly an error; it's just a status indication. |
> | 103 | The socket was unable to resolve the address that was specified. |
> | 104 | This error code is no longer used. |
> | 105 | The address is currently in use. |
> | 106 | This is an invalid state error, which means that the socket is not in the proper state to be doing a certain operation. |
> | 107 | This error means that the port you specified is invalid. |
> | 108 | This error indicates that your application has run out of memory. |
>
> Information on `additional error codes` is available.
>
> The following example in the Error event handler displays the error code.
>
> ``` xojo
> MessageBox(e.ErrorNumber.ToString)
> ```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SMTPSecureSocket.MailSent
**MailSent**
> Executes when all of the messages in the queue have been sent.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SMTPSecureSocket.MessageSent
**MessageSent**(Email As `EmailMessage`)
> Executes when a message has been sent; *Email* contains the message that was sent.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SMTPSecureSocket.SendProgress
**SendProgress**(BytesSent As `Integer`, BytesLeft As `Integer`) As `Boolean`
> Occurs when your network provider queues your data in chunks and is about to send the next chunk.
>
> The parameters indicate the amount of progress that has been made during the send. Returns a `Boolean`.
>
> Returning `True` from this event causes the send to be cancelled. This does not close the socket's connection; it only clears the buffer. After all of the data has been transferred you will get a final SendProgress event followed by a `SendComplete` event.
>
> *bytesSent* is the number of bytes that were sent in the chunk, not the total number of bytes sent.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
forsearch
SMTPSecureSocket.ServerError
**ServerError**(ErrorID As `Integer`, ErrorMessage As `String`, Email As `EmailMessage`)
> Executes when an error occured while sending a message.
>
> *ErrorID* and *ErrorMessage* are sent by the mail server and *Email* is the message that was being sent when the error occurred. *Email* is removed from the queue at the time the event executes.
## Interfaces
This class implements the `Readable` and `Writeable` class interfaces.
## Notes
The SMTPSecureSocket class is the same as the SMTPSecureSocket class except that it is derived from `SSLSocket` instead of `TCPSocket`. As a result, you can use the Secure property of the `SSLSocket` class to provide secure communications.
If you use a constructor in a subclass of a SMTPSecureSocket, you must call the Super class's constructor in your subclass's constructor. The subclass will not work unless this is done.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
### Error codes
For a list of codes, refer here:
- [Understanding SMTP Error Codes](https://www.lifewire.com/smtp-error-messages-1166422)
- [RFC 5321](https://tools.ietf.org/html/rfc5321#section-4.2)
Keep in mind that some codes may be server specific.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
### Gmail
In order to connect to Gmail you'll need to enable the "allow less secure apps" option as described in this Google support document:
With that enabled, these settings work for most users:
``` xojo
MailSocket.Address = "smtp.gmail.com"
MailSocket.Port = 465
MailSocket.SSLConnectionType = SSLSocket.SSLConnectionTypes.TLSv1
MailSocket.SMTPConnectionType = SMTPSecureSocket.SMTPConnectionTypes.SSLTLS
MailSocket.SSLEnabled = True
MailSocket.UserName =
MailSocket.Password =
```
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
### Xojo Cloud
To access an SMTP server from web apps running on Xojo Cloud, you will first have to use the `FirewallPort` class to open the port used to connect to the SMTP Server:
``` xojo
Var fwp As New XojoCloud.FirewallPort(587, XojoCloud.FirewallPort.Direction.Outgoing)
fwp.Open ' This call is synchronous
If fwp.isOpen Then
' Do what you need to do
End If
```
## Sample code
This code uses an SMTPSecureSocket called MailSocket that has been added to a Window to send a simple email using Gmail. Update the Username, Password and email address in this code to use it.
``` xojo
' Connect to Gmail
MailSocket.Address = "smtp.gmail.com"
MailSocket.Port = 465
MailSocket.SSLConnectionType = SSLSocket.SSLConnectionTypes.TLSv1
MailSocket.SMTPConnectionType = SMTPSecureSocket.SMTPConnectionTypes.SSLTLS
MailSocket.SSLEnabled = True
MailSocket.Username = "" ' Provide your Gmail username
MailSocket.Password = "" ' Provide your Gmail password
' Create EmailMessage
Var mail As New EmailMessage
mail.FromAddress = "myemail@mydomain.com" ' Your from email address
mail.AddRecipient("recipient@domain.com") ' The recipient's email address
mail.Subject = "Test from Xojo"
mail.BodyPlainText = "This email was sent from a Xojo app."
mail.Headers.AddHeader("X-Mailer","SMTP Test")
' Send it
MailSocket.Messages.AddRow(mail)
MailSocket.SendMail
```
## Compatibility
| | |
|-----------------------|-----------------------|
| **Project Types** | Console, Desktop, Web |
| **Operating Systems** | All |
`SSLSocket` parent class; `EmailMessage`, `URLConnection`, `URLConnection`, `POP3SecureSocket`, `TCPSocket`, `POP3SecureSocket`, `SocketCore` classes.