public bool Update(int patternID, string name, string description, int?virtualMTA, OutboundMxPatternType type, string patternValue, int maxConnections, int maxMessagesConn, int maxMessagesHour)
{
if (virtualMTA == -1)
{
virtualMTA = null;
}
OutboundMxPattern pattern = null;
if (patternID == WebInterfaceLib.WebInterfaceParameters.OUTBOUND_RULES_NEW_PATTERN_ID)
{
pattern = new OutboundMxPattern();
}
else
{
pattern = MantaMTA.Core.DAL.OutboundRuleDB.GetOutboundRulePatterns().SingleOrDefault(p => p.ID == patternID);
}
if (pattern == null)
{
return(false);
}
pattern.Description = description.Trim();
pattern.LimitedToOutboundIpAddressID = virtualMTA;
pattern.Name = name.Trim();
pattern.Type = type;
pattern.Value = patternValue;
pattern.ID = OutboundRuleWebManager.Save(pattern);
OutboundRuleWebManager.Save(new OutboundRule(pattern.ID, OutboundRuleType.MaxConnections, maxConnections.ToString()));
OutboundRuleWebManager.Save(new OutboundRule(pattern.ID, OutboundRuleType.MaxMessagesConnection, maxMessagesConn.ToString()));
OutboundRuleWebManager.Save(new OutboundRule(pattern.ID, OutboundRuleType.MaxMessagesPerHour, maxMessagesHour.ToString()));
return(true);
}
public bool Update(UpdateOutboundRuleViewModel viewModel)
{
if (viewModel.VirtualMTA == -1)
{
viewModel.VirtualMTA = null;
}
OutboundMxPattern pattern = null;
if (viewModel.PatternID == WebInterfaceParameters.OUTBOUND_RULES_NEW_PATTERN_ID)
{
pattern = new OutboundMxPattern();
}
else
{
pattern = OutboundRuleDB.GetOutboundRulePatterns().SingleOrDefault(p => p.ID == viewModel.PatternID);
}
if (pattern == null)
{
return(false);
}
pattern.Description = viewModel.Description.Trim();
pattern.LimitedToOutboundIpAddressID = viewModel.VirtualMTA;
pattern.Name = viewModel.Name.Trim();
pattern.Type = viewModel.Type;
pattern.Value = viewModel.PatternValue;
pattern.ID = OutboundRuleWebManager.Save(pattern);
OutboundRuleWebManager.Save(new OutboundRule(pattern.ID, OutboundRuleType.MaxConnections, viewModel.MaxConnections.ToString()));
OutboundRuleWebManager.Save(new OutboundRule(pattern.ID, OutboundRuleType.MaxMessagesConnection, viewModel.MaxMessagesConn.ToString()));
OutboundRuleWebManager.Save(new OutboundRule(pattern.ID, OutboundRuleType.MaxMessagesPerHour, viewModel.MaxMessagesHour.ToString()));
return(true);
}
/// <summary>
/// Saves the specified OutboundMxPattern to the database.
/// </summary>
/// <param name="mxPattern">The OutboundMxPattern to save.</param>
/// <returns>ID of the OutboundMxPattern.</returns>
public static int Save(OutboundMxPattern mxPattern)
{
using (SqlConnection conn = MantaDB.GetSqlConnection())
{
SqlCommand cmd = conn.CreateCommand();
cmd.CommandText = @"
IF EXISTS (SELECT 1 FROM man_rle_mxPattern WHERE rle_mxPattern_id = @mxPatternID)
BEGIN
UPDATE man_rle_mxPattern
SET rle_mxPattern_name = @name,
rle_mxPattern_description = @description,
rle_patternType_id = @type,
rle_mxPattern_value = @value,
ip_ipAddress_id = @ipAddressID
WHERE rle_mxPattern_id = @mxPatternID
SELECT @mxPatternID
END
ELSE
BEGIN
INSERT INTO man_rle_mxPattern(rle_mxPattern_name, rle_mxPattern_description, rle_patternType_id, rle_mxPattern_value, ip_ipAddress_id)
VALUES(@name, @description, @type, @value, @ipAddressID)
SELECT @@IDENTITY
END
";
cmd.Parameters.AddWithValue("@mxPatternID", mxPattern.ID);
cmd.Parameters.AddWithValue("@name", mxPattern.Name);
if (mxPattern.Description == null)
{
cmd.Parameters.AddWithValue("@description", DBNull.Value);
}
else
{
cmd.Parameters.AddWithValue("@description", mxPattern.Description);
}
cmd.Parameters.AddWithValue("@type", (int)mxPattern.Type);
cmd.Parameters.AddWithValue("@value", mxPattern.Value);
if (mxPattern.LimitedToOutboundIpAddressID.HasValue)
{
cmd.Parameters.AddWithValue("@ipAddressID", mxPattern.LimitedToOutboundIpAddressID.Value);
}
else
{
cmd.Parameters.AddWithValue("@ipAddressID", DBNull.Value);
}
conn.Open();
return(Convert.ToInt32(cmd.ExecuteScalar()));
}
}
/// <summary>
/// Create and fill an OutboundMxPattern object from the Data Record.
/// </summary>
/// <param name="record">Datarecord containing values for the new object.</param>
/// <returns>OutboundMxPattern object.</returns>
private static OutboundMxPattern CreateAndFillOutboundMxPattern(IDataRecord record)
{
OutboundMxPattern mxPattern = new OutboundMxPattern();
mxPattern.Description = record.GetStringOrEmpty("rle_mxPattern_description");
mxPattern.ID = record.GetInt32("rle_mxPattern_id");
mxPattern.Name = record.GetString("rle_mxPattern_name");
if (!record.IsDBNull("ip_ipAddress_id"))
{
mxPattern.LimitedToOutboundIpAddressID = record.GetInt32("ip_ipAddress_id");
}
mxPattern.Type = (OutboundMxPatternType)record.GetInt32("rle_patternType_id");
mxPattern.Value = record.GetString("rle_mxPattern_value");
return(mxPattern);
}
/// <summary>
/// Creates a new MX Pattern and it's default rules.
/// </summary>
/// <param name="name">Name of the pattern.</param>
/// <param name="description">Description of the pattern.</param>
/// <param name="type">The Type of the pattern.</param>
/// <param name="pattern">The pattern value.</param>
/// <param name="ipAddress">IP Address to limit the outbound rule to, or null if applies to all IP's.</param>
/// <returns>ID of the MX Pattern.</returns>
public static int CreatePattern(string name, string description, OutboundMxPatternType type, string pattern, int?ipAddress)
{
OutboundMxPattern mxPattern = new OutboundMxPattern
{
Description = description,
Name = name,
Type = type,
Value = pattern,
LimitedToOutboundIpAddressID = ipAddress
};
mxPattern.ID = Save(mxPattern);
// Create the three types of rule.
Save(new OutboundRule(mxPattern.ID, OutboundRuleType.MaxConnections, "-1"));
Save(new OutboundRule(mxPattern.ID, OutboundRuleType.MaxMessagesConnection, "-1"));
Save(new OutboundRule(mxPattern.ID, OutboundRuleType.MaxMessagesPerHour, "-1"));
return(mxPattern.ID);
}
//
// GET: /OutboundRules/Edit?id=
public ActionResult Edit(int id = WebInterfaceParameters.OUTBOUND_RULES_NEW_PATTERN_ID)
{
OutboundMxPattern pattern = null;
IList <OutboundRule> rules = null;
if (id != WebInterfaceParameters.OUTBOUND_RULES_NEW_PATTERN_ID)
{
pattern = OutboundRuleDB.GetOutboundRulePatterns().Single(p => p.ID == id);
rules = OutboundRuleDB.GetOutboundRules().Where(r => r.OutboundMxPatternID == id).ToList();
}
else
{
pattern = new OutboundMxPattern();
rules = OutboundRuleDB.GetOutboundRules().Where(r => r.OutboundMxPatternID == MtaParameters.OUTBOUND_RULES_DEFAULT_PATTERN_ID).ToList();
}
IList <VirtualMTA> vMtas = VirtualMtaDB.GetVirtualMtas();
return(View(new OutboundRuleModel(rules, pattern, vMtas)));
}
//
// GET: /OutboundRules/Edit?id=
public ActionResult Edit(int id = WebInterfaceParameters.OUTBOUND_RULES_NEW_PATTERN_ID)
{
OutboundMxPattern pattern = null;
OutboundRuleCollection rules = null;
if (id != WebInterfaceParameters.OUTBOUND_RULES_NEW_PATTERN_ID)
{
pattern = OutboundRuleDB.GetOutboundRulePatterns().Single(p => p.ID == id);
rules = new OutboundRuleCollection(OutboundRuleDB.GetOutboundRules().Where(r => r.OutboundMxPatternID == id).ToArray());
}
else
{
pattern = new OutboundMxPattern();
rules = new OutboundRuleCollection(OutboundRuleDB.GetOutboundRules().Where(r => r.OutboundMxPatternID == MantaMTA.Core.MtaParameters.OUTBOUND_RULES_DEFAULT_PATTERN_ID));
}
VirtualMTACollection vMtas = MantaMTA.Core.DAL.VirtualMtaDB.GetVirtualMtas();
return(View(new OutboundRuleModel(rules, pattern, vMtas)));
}
/// <summary>
/// Saves the OutboundMxPattern.
/// </summary>
/// <param name="pattern">Pattern to save.</param>
/// <returns>ID of the pattern.</returns>
public static int Save(OutboundMxPattern pattern)
{
return(DAL.OutboundRulesDB.Save(pattern));
}
/// <summary>
/// Gets the MxPatternID that matches the MX Record, Outbound IP Address combo.
/// </summary>
/// <param name="record"></param>
/// <param name="ipAddress"></param>
/// <returns></returns>
private static int GetMxPatternID(MXRecord record, VirtualMTA ipAddress)
{
if (_matchedPatterns == null)
{
_matchedPatterns = new ConcurrentDictionary <string, MatchedMxPatternCollection>();
}
MatchedMxPatternCollection matchedPatterns = null;
if (!_matchedPatterns.TryGetValue(record.Host, out matchedPatterns))
{
matchedPatterns = new MatchedMxPatternCollection();
_matchedPatterns.AddOrUpdate(record.Host, matchedPatterns, (string s, MatchedMxPatternCollection p) => matchedPatterns);
}
MatchedMxPattern matchedPattern = matchedPatterns.GetMatchedMxPattern(ipAddress);
if (matchedPattern != null &&
matchedPattern.MatchedUtc.AddMinutes(MtaParameters.MTA_CACHE_MINUTES) > DateTime.UtcNow)
{
// Found a valid cached pattern ID so return it.
return(matchedPattern.MxPatternID);
}
// Loop through all of the patterns
for (int i = 0; i < _MXPatterns.Count; i++)
{
// The current pattern we're working with.
OutboundMxPattern pattern = _MXPatterns[i];
// If the pattern applies only to a specified IP address then
// only check for a match if getting rules for that IP.
if (pattern.LimitedToOutboundIpAddressID.HasValue &&
pattern.LimitedToOutboundIpAddressID.Value != ipAddress.ID)
{
continue;
}
if (pattern.Type == OutboundMxPatternType.CommaDelimited)
{
// Pattern is a comma delimited list, so split the values
string[] strings = pattern.Value.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
// Loop though the values in the split string array.
for (int c = 0; c < strings.Length; c++)
{
try
{
// If they are a match return the rules.
if (strings[c].Equals(record.Host, StringComparison.OrdinalIgnoreCase))
{
if (pattern.LimitedToOutboundIpAddressID.HasValue)
{
matchedPatterns.Add(pattern.ID, ipAddress);
}
else
{
matchedPatterns.Add(pattern.ID, null);
}
return(pattern.ID);
}
}
catch (Exception) { }
}
continue;
}
else if (pattern.Type == OutboundMxPatternType.Regex)
{
// Pattern is Regex so just need to do an IsMatch
if (Regex.IsMatch(record.Host, pattern.Value, RegexOptions.IgnoreCase | RegexOptions.ExplicitCapture))
{
// Found pattern match.
if (pattern.LimitedToOutboundIpAddressID.HasValue)
{
matchedPatterns.Add(pattern.ID, ipAddress);
}
else
{
matchedPatterns.Add(pattern.ID, null);
}
return(pattern.ID);
}
else
{
continue;
}
}
else
{
// Don't know what to do with this pattern so move on to the next.
Logging.Error("Unknown OutboundMxPatternType : " + pattern.Type.ToString());
continue;
}
}
// Should have been found by default at least, but hasn't.
Logging.Fatal("No MX Pattern Rules! Default Deleted?");
MantaCoreEvents.InvokeMantaCoreStopping();
Environment.Exit(0);
return(-1);
}
public OutboundRuleModel(IList <OutboundRule> outboundRuleCollection, OutboundMxPattern pattern, IList <VirtualMTA> virtualMtaCollection)
{
OutboundRules = outboundRuleCollection;
Pattern = pattern;
VirtualMtaCollection = virtualMtaCollection;
}
public OutboundRuleModel(OutboundRuleCollection outboundRuleCollection, OutboundMxPattern pattern, VirtualMTACollection virtualMtaCollection)
{
OutboundRules = outboundRuleCollection;
Pattern = pattern;
VirtualMtaCollection = virtualMtaCollection;
}
