484 lines
18 KiB
C#
484 lines
18 KiB
C#
/*
|
|
* Copyright (c) Contributors, http://opensimulator.org/
|
|
* See CONTRIBUTORS.TXT for a full list of copyright holders.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* * Neither the name of the OpenSimulator Project nor the
|
|
* names of its contributors may be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
|
|
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Net.Security;
|
|
using System.Reflection;
|
|
using System.Security.Cryptography.X509Certificates;
|
|
using log4net;
|
|
using MailKit;
|
|
using MailKit.Net.Smtp;
|
|
using MimeKit;
|
|
using Nini.Config;
|
|
using OpenMetaverse;
|
|
using OpenSim.Framework;
|
|
using OpenSim.Region.Framework.Interfaces;
|
|
using OpenSim.Region.Framework.Scenes;
|
|
using Mono.Addins;
|
|
|
|
namespace OpenSim.Region.CoreModules.Scripting.EmailModules
|
|
{
|
|
[Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "EmailModule")]
|
|
public class EmailModule : ISharedRegionModule, IEmailModule
|
|
{
|
|
//
|
|
// Log
|
|
//
|
|
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
|
|
|
|
//
|
|
// Module vars
|
|
//
|
|
private string m_HostName = string.Empty;
|
|
private bool SMTP_SERVER_TLS = false;
|
|
private string SMTP_SERVER_HOSTNAME = string.Empty;
|
|
private int SMTP_SERVER_PORT = 25;
|
|
private MailboxAddress SMTP_MAIL_FROM = null;
|
|
private string SMTP_SERVER_LOGIN = string.Empty;
|
|
private string SMTP_SERVER_PASSWORD = string.Empty;
|
|
|
|
private ParserOptions m_mailParseOptions;
|
|
|
|
private int m_MaxQueueSize = 50; // maximum size of an object mail queue
|
|
private Dictionary<UUID, List<Email>> m_MailQueues = new Dictionary<UUID, List<Email>>();
|
|
private Dictionary<UUID, double> m_LastGetEmailCall = new Dictionary<UUID, double>();
|
|
private double m_QueueTimeout = 30 * 60; // 15min;
|
|
private double m_nextQueuesExpire;
|
|
private string m_InterObjectHostname = "lsl.opensim.local";
|
|
|
|
private int m_MaxEmailSize = 4096; // largest email allowed by default, as per lsl docs.
|
|
|
|
private static SslPolicyErrors m_SMTP_SslPolicyErrorsMask;
|
|
private bool m_checkSpecName;
|
|
|
|
private object m_queuesLock = new object();
|
|
|
|
// Scenes by Region Handle
|
|
private Dictionary<ulong, Scene> m_Scenes = new Dictionary<ulong, Scene>();
|
|
|
|
private bool m_Enabled = false;
|
|
|
|
#region ISharedRegionModule
|
|
|
|
public void Initialise(IConfigSource config)
|
|
{
|
|
IConfig startupConfig = config.Configs["Startup"];
|
|
if(startupConfig == null)
|
|
return;
|
|
|
|
if(startupConfig.GetString("emailmodule", "DefaultEmailModule") != "DefaultEmailModule")
|
|
return;
|
|
|
|
//Load SMTP SERVER config
|
|
try
|
|
{
|
|
IConfig SMTPConfig = config.Configs["SMTP"];
|
|
if (SMTPConfig == null)
|
|
return;
|
|
|
|
if (!SMTPConfig.GetBoolean("enabled", false))
|
|
return;
|
|
|
|
m_mailParseOptions = new ParserOptions()
|
|
{
|
|
AllowAddressesWithoutDomain = false,
|
|
};
|
|
|
|
m_HostName = SMTPConfig.GetString("host_domain_header_from", m_HostName);
|
|
m_InterObjectHostname = SMTPConfig.GetString("internal_object_host", m_InterObjectHostname);
|
|
SMTP_SERVER_TLS = SMTPConfig.GetBoolean("SMTP_SERVER_TLS", SMTP_SERVER_TLS);
|
|
SMTP_SERVER_HOSTNAME = SMTPConfig.GetString("SMTP_SERVER_HOSTNAME", SMTP_SERVER_HOSTNAME);
|
|
OSHHTPHost hosttmp = new OSHHTPHost(SMTP_SERVER_HOSTNAME, true);
|
|
if(!hosttmp.IsResolvedHost)
|
|
{
|
|
m_log.ErrorFormat("[EMAIL]: could not resolve SMTP_SERVER_HOSTNAME {0}", SMTP_SERVER_HOSTNAME);
|
|
return;
|
|
}
|
|
|
|
SMTP_SERVER_PORT = SMTPConfig.GetInt("SMTP_SERVER_PORT", SMTP_SERVER_PORT);
|
|
string smtpfrom = SMTPConfig.GetString("SMTP_SERVER_FROM", string.Empty);
|
|
if(!string.IsNullOrEmpty(smtpfrom) && !MailboxAddress.TryParse(m_mailParseOptions, smtpfrom, out SMTP_MAIL_FROM))
|
|
{
|
|
m_log.ErrorFormat("[EMAIL]: Invalid SMTP_SERVER_FROM {0}", smtpfrom);
|
|
return;
|
|
}
|
|
|
|
SMTP_SERVER_LOGIN = SMTPConfig.GetString("SMTP_SERVER_LOGIN", SMTP_SERVER_LOGIN);
|
|
SMTP_SERVER_PASSWORD = SMTPConfig.GetString("SMTP_SERVER_PASSWORD", SMTP_SERVER_PASSWORD);
|
|
m_MaxEmailSize = SMTPConfig.GetInt("email_max_size", m_MaxEmailSize);
|
|
if(m_MaxEmailSize < 256 || m_MaxEmailSize > 1000000)
|
|
{
|
|
m_log.Warn("[EMAIL]: email_max_size out of range [256, 1000000], Changed to default 4096");
|
|
m_MaxEmailSize = 4096;
|
|
}
|
|
|
|
bool VerifyCertChain = SMTPConfig.GetBoolean("SMTP_VerifyCertChain", true);
|
|
bool VerifyCertNames = SMTPConfig.GetBoolean("SMTP_VerifyCertNames", true);
|
|
m_SMTP_SslPolicyErrorsMask = VerifyCertChain ? 0 : SslPolicyErrors.RemoteCertificateChainErrors;
|
|
if(!VerifyCertNames)
|
|
m_SMTP_SslPolicyErrorsMask |= SslPolicyErrors.RemoteCertificateNameMismatch;
|
|
m_SMTP_SslPolicyErrorsMask = ~m_SMTP_SslPolicyErrorsMask;
|
|
|
|
m_checkSpecName = !m_InterObjectHostname.Equals("lsl.secondlife.com");
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
m_log.Error("[EMAIL]: DefaultEmailModule not configured: " + e.Message);
|
|
return;
|
|
}
|
|
|
|
m_nextQueuesExpire = Util.GetTimeStamp() + m_QueueTimeout;
|
|
m_Enabled = true;
|
|
}
|
|
|
|
public void AddRegion(Scene scene)
|
|
{
|
|
if (!m_Enabled)
|
|
return;
|
|
|
|
// It's a go!
|
|
lock (m_Scenes)
|
|
{
|
|
// Claim the interface slot
|
|
scene.RegisterModuleInterface<IEmailModule>(this);
|
|
|
|
// Add to scene list
|
|
m_Scenes[scene.RegionInfo.RegionHandle] = scene;
|
|
}
|
|
|
|
m_log.Info("[EMAIL]: Activated DefaultEmailModule");
|
|
}
|
|
|
|
public void RemoveRegion(Scene scene)
|
|
{
|
|
}
|
|
|
|
public void PostInitialise()
|
|
{
|
|
}
|
|
|
|
public void Close()
|
|
{
|
|
}
|
|
|
|
public string Name
|
|
{
|
|
get { return "DefaultEmailModule"; }
|
|
}
|
|
|
|
public Type ReplaceableInterface
|
|
{
|
|
get { return null; }
|
|
}
|
|
|
|
public void RegionLoaded(Scene scene)
|
|
{
|
|
}
|
|
|
|
#endregion
|
|
|
|
public void AddPartMailBox(UUID objectID)
|
|
{
|
|
lock (m_queuesLock)
|
|
{
|
|
if (!m_MailQueues.TryGetValue(objectID, out List<Email> elist))
|
|
{
|
|
m_MailQueues[objectID] = null;
|
|
//TODO external global
|
|
}
|
|
}
|
|
}
|
|
|
|
public void RemovePartMailBox(UUID objectID)
|
|
{
|
|
lock (m_queuesLock)
|
|
{
|
|
m_LastGetEmailCall.Remove(objectID);
|
|
if (m_MailQueues.Remove(objectID))
|
|
{
|
|
//TODO external global
|
|
}
|
|
}
|
|
}
|
|
|
|
public void InsertEmail(UUID to, Email email)
|
|
{
|
|
lock (m_queuesLock)
|
|
{
|
|
if (m_MailQueues.TryGetValue(to, out List<Email> elist))
|
|
{
|
|
if(elist == null)
|
|
{
|
|
elist = new List<Email>();
|
|
elist.Add(email);
|
|
m_MailQueues[to] = elist;
|
|
}
|
|
else
|
|
{
|
|
if (elist.Count >= m_MaxQueueSize)
|
|
return;
|
|
lock (elist)
|
|
elist.Add(email);
|
|
}
|
|
m_LastGetEmailCall[to] = Util.GetTimeStamp() + m_QueueTimeout;
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool IsLocal(UUID objectID)
|
|
{
|
|
lock (m_Scenes)
|
|
{
|
|
foreach (Scene s in m_Scenes.Values)
|
|
{
|
|
if (s.GetSceneObjectPart(objectID) != null)
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private SceneObjectPart findPrim(UUID objectID, out string ObjectRegionName)
|
|
{
|
|
lock (m_Scenes)
|
|
{
|
|
foreach (Scene s in m_Scenes.Values)
|
|
{
|
|
SceneObjectPart part = s.GetSceneObjectPart(objectID);
|
|
if (part != null)
|
|
{
|
|
RegionInfo sri = s.RegionInfo;
|
|
ObjectRegionName = sri.RegionName;
|
|
ObjectRegionName = ObjectRegionName + " (" + sri.WorldLocX + ", " + sri.WorldLocY + ")";
|
|
return part;
|
|
}
|
|
}
|
|
}
|
|
ObjectRegionName = string.Empty;
|
|
return null;
|
|
}
|
|
|
|
private bool resolveNamePositionRegionName(UUID objectID, out string ObjectName, out string ObjectAbsolutePosition, out string ObjectRegionName)
|
|
{
|
|
SceneObjectPart part = findPrim(objectID, out ObjectRegionName);
|
|
if (part != null)
|
|
{
|
|
Vector3 pos = part.AbsolutePosition;
|
|
ObjectAbsolutePosition = "(" + (int)pos.X + ", " + (int)pos.Y + ", " + (int)pos.Z + ")";
|
|
ObjectName = part.Name;
|
|
return true;
|
|
}
|
|
ObjectName = ObjectAbsolutePosition = ObjectRegionName = string.Empty;
|
|
return false;
|
|
}
|
|
|
|
public static bool smptValidateServerCertificate(object sender, X509Certificate certificate,
|
|
X509Chain chain, SslPolicyErrors sslPolicyErrors)
|
|
{
|
|
return (sslPolicyErrors & m_SMTP_SslPolicyErrorsMask) == SslPolicyErrors.None;
|
|
}
|
|
|
|
/// <summary>
|
|
/// SendMail function utilized by llEMail
|
|
/// </summary>
|
|
/// <param name="objectID"></param>
|
|
/// <param name="address"></param>
|
|
/// <param name="subject"></param>
|
|
/// <param name="body"></param>
|
|
public void SendEmail(UUID objectID, string address, string subject, string body)
|
|
{
|
|
//Check if address is empty
|
|
if (address.Length == 0)
|
|
return;
|
|
|
|
if(!MailboxAddress.TryParse(address, out MailboxAddress mailTo))
|
|
{
|
|
m_log.ErrorFormat("[EMAIL]: invalid TO email address {0}",address);
|
|
return;
|
|
}
|
|
|
|
if ((subject.Length + body.Length) > m_MaxEmailSize)
|
|
{
|
|
m_log.Error("[EMAIL]: subject + body larger than limit of " + m_MaxEmailSize + " bytes");
|
|
return;
|
|
}
|
|
|
|
if (!resolveNamePositionRegionName(objectID, out string LastObjectName, out string LastObjectPosition, out string LastObjectRegionName))
|
|
return;
|
|
|
|
string objectIDstr = objectID.ToString();
|
|
if (!address.EndsWith(m_InterObjectHostname, StringComparison.InvariantCultureIgnoreCase) &&
|
|
!(m_checkSpecName && address.EndsWith("lsl.secondlife.com", StringComparison.InvariantCultureIgnoreCase)))
|
|
{
|
|
// regular email, send it out
|
|
try
|
|
{
|
|
//Creation EmailMessage
|
|
MimeMessage mmsg = new MimeMessage();
|
|
|
|
if(SMTP_MAIL_FROM != null)
|
|
{
|
|
mmsg.From.Add(SMTP_MAIL_FROM);
|
|
mmsg.Subject = "(OSObj" + objectIDstr + ") " + subject;
|
|
}
|
|
else
|
|
{
|
|
mmsg.From.Add(MailboxAddress.Parse(objectIDstr + "@" + m_HostName));
|
|
mmsg.Subject = subject;
|
|
}
|
|
|
|
mmsg.To.Add(mailTo);
|
|
mmsg.Body = new TextPart("plain") {
|
|
Text = "Object-Name: " + LastObjectName +
|
|
"\nRegion: " + LastObjectRegionName + "\nLocal-Position: " +
|
|
LastObjectPosition + "\n\n" + body
|
|
};
|
|
|
|
using (var client = new SmtpClient())
|
|
{
|
|
if (SMTP_SERVER_TLS)
|
|
{
|
|
client.ServerCertificateValidationCallback = smptValidateServerCertificate;
|
|
client.Connect(SMTP_SERVER_HOSTNAME, SMTP_SERVER_PORT, MailKit.Security.SecureSocketOptions.StartTls);
|
|
}
|
|
else
|
|
client.Connect(SMTP_SERVER_HOSTNAME, SMTP_SERVER_PORT);
|
|
|
|
if (!string.IsNullOrEmpty(SMTP_SERVER_LOGIN) && !string.IsNullOrEmpty(SMTP_SERVER_PASSWORD))
|
|
client.Authenticate(SMTP_SERVER_LOGIN, SMTP_SERVER_PASSWORD);
|
|
|
|
client.Send(mmsg);
|
|
client.Disconnect(true);
|
|
}
|
|
|
|
//Log
|
|
m_log.Info("[EMAIL]: EMail sent to: " + address + " from object: " + objectID.ToString() + "@" + m_HostName);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
m_log.Error("[EMAIL]: DefaultEmailModule Exception: " + e.Message);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// inter object email
|
|
int indx = address.IndexOf('@');
|
|
if (indx < 0)
|
|
return;
|
|
if (!UUID.TryParse(address.Substring(0, indx), out UUID toID))
|
|
return;
|
|
|
|
Email email = new Email();
|
|
email.time = Util.UnixTimeSinceEpoch().ToString();
|
|
email.subject = subject;
|
|
email.sender = objectID.ToString() + "@" + m_InterObjectHostname;
|
|
email.message = "Object-Name: " + LastObjectName +
|
|
"\nRegion: " + LastObjectRegionName + "\nLocal-Position: " +
|
|
LastObjectPosition + "\n\n" + body;
|
|
|
|
if (IsLocal(toID))
|
|
{
|
|
// object in this region
|
|
InsertEmail(toID, email);
|
|
}
|
|
else
|
|
{
|
|
// object on another region
|
|
// TODO FIX
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="objectID"></param>
|
|
/// <param name="sender"></param>
|
|
/// <param name="subject"></param>
|
|
/// <returns></returns>
|
|
public Email GetNextEmail(UUID objectID, string sender, string subject)
|
|
{
|
|
lock (m_queuesLock)
|
|
{
|
|
double now = Util.GetTimeStamp();
|
|
m_LastGetEmailCall[objectID] = now + m_QueueTimeout;
|
|
|
|
if( now > m_nextQueuesExpire)
|
|
{
|
|
List<UUID> removal = new List<UUID>(m_LastGetEmailCall.Count);
|
|
foreach (KeyValuePair<UUID, double> kpv in m_LastGetEmailCall)
|
|
{
|
|
if (kpv.Value < now)
|
|
removal.Add(kpv.Key);
|
|
}
|
|
|
|
foreach (UUID remove in removal)
|
|
{
|
|
m_LastGetEmailCall.Remove(remove);
|
|
m_MailQueues[remove] = null;
|
|
}
|
|
m_nextQueuesExpire = now + m_QueueTimeout;
|
|
}
|
|
|
|
m_MailQueues.TryGetValue(objectID, out List<Email> queue);
|
|
if (queue != null)
|
|
{
|
|
lock (queue)
|
|
{
|
|
if (queue.Count > 0)
|
|
{
|
|
bool emptySender = string.IsNullOrEmpty(sender);
|
|
bool emptySubject = string.IsNullOrEmpty(subject);
|
|
|
|
int i;
|
|
Email ret;
|
|
for (i = 0; i < queue.Count; i++)
|
|
{
|
|
ret = queue[i];
|
|
if (emptySender || sender.Equals(ret.sender, StringComparison.InvariantCultureIgnoreCase) &&
|
|
(emptySubject || subject.Equals(ret.subject, StringComparison.InvariantCultureIgnoreCase)))
|
|
{
|
|
queue.RemoveAt(i);
|
|
ret.numLeft = queue.Count;
|
|
if (queue.Count == 0)
|
|
{
|
|
m_MailQueues[objectID] = null;
|
|
m_LastGetEmailCall.Remove(objectID);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
}
|