/// <summary>
/// Cleans up any resource being used.
/// </summary>
public void Dispose()
{
lock (m_pLock)
{
if (this.State == DNS_ClientTransactionState.Disposed)
{
return;
}
SetState(DNS_ClientTransactionState.Disposed);
if (m_pTimeoutTimer != null)
{
m_pTimeoutTimer.Dispose();
m_pTimeoutTimer = null;
}
m_pOwner = null;
m_pResponse = null;
this.StateChanged = null;
this.Timeout = null;
}
}
/// <summary>
/// Default constructor.
/// </summary>
/// <param name="owner">Owner DNS client.</param>
/// <param name="dnsServers">DNS servers.</param>
/// <param name="id">Transaction ID.</param>
/// <param name="qtype">QTYPE value.</param>
/// <param name="qname">QNAME value.</param>
/// <param name="timeout">Timeout in milliseconds.</param>
/// <exception cref="ArgumentNullException">Is raised when <b>owner</b> or <b>qname</b> is null reference.</exception>
internal DNS_ClientTransaction(Dns_Client owner, IPAddress[] dnsServers, int id, DNS_QType qtype, string qname, int timeout)
{
if (owner == null)
{
throw new ArgumentNullException("owner");
}
if (dnsServers == null)
{
throw new ArgumentNullException("dnsServers");
}
if (qname == null)
{
throw new ArgumentNullException("qname");
}
m_pOwner = owner;
m_pDnsServers = dnsServers;
m_ID = id;
m_QName = qname;
m_QType = qtype;
m_CreateTime = DateTime.Now;
m_pTimeoutTimer = new TimerEx(timeout);
m_pTimeoutTimer.Elapsed += new System.Timers.ElapsedEventHandler(m_pTimeoutTimer_Elapsed);
}
/// <summary>
/// Resolves host name to IP addresses.
/// </summary>
/// <param name="host">Host name or IP address.</param>
/// <returns>Return specified host IP addresses.</returns>
/// <exception cref="ArgumentNullException">Is raised when <b>host</b> is null.</exception>
public static IPAddress[] Resolve(string host)
{
if (host == null)
{
throw new ArgumentNullException("host");
}
// If hostName_IP is IP
try
{
return(new IPAddress[] { IPAddress.Parse(host) });
}
catch
{
}
// This is probably NetBios name
if (host.IndexOf(".") == -1)
{
return(System.Net.Dns.GetHostEntry(host).AddressList);
}
else
{
// hostName_IP must be host name, try to resolve it's IP
using (Dns_Client dns = new Dns_Client())
{
DnsServerResponse resp = dns.Query(host, DNS_QType.A);
if (resp.ResponseCode == DNS_RCode.NO_ERROR)
{
DNS_rr_A[] records = resp.GetARecords();
IPAddress[] retVal = new IPAddress[records.Length];
for (int i = 0; i < records.Length; i++)
{
retVal[i] = records[i].IP;
}
return(retVal);
}
else
{
throw new Exception(resp.ResponseCode.ToString());
}
}
}
}
/// <summary>
/// Default constructor.
/// </summary>
/// <param name="owner">Owner DNS client.</param>
/// <param name="id">Transaction ID.</param>
/// <param name="qtype">QTYPE value.</param>
/// <param name="qname">QNAME value.</param>
/// <param name="timeout">Timeout in milliseconds.</param>
/// <exception cref="ArgumentNullException">Is raised when <b>owner</b> or <b>qname</b> is null reference.</exception>
internal DNS_ClientTransaction(Dns_Client owner,int id,DNS_QType qtype,string qname,int timeout)
{
if(owner == null){
throw new ArgumentNullException("owner");
}
if(qname == null){
throw new ArgumentNullException("qname");
}
m_pOwner = owner;
m_ID = id;
m_QName = qname;
m_QType = qtype;
m_CreateTime = DateTime.Now;
m_pTimeoutTimer = new TimerEx(timeout);
m_pTimeoutTimer.Elapsed += new System.Timers.ElapsedEventHandler(m_pTimeoutTimer_Elapsed);
}
/// <summary>
/// Default constructor.
/// </summary>
public SIP_Stack()
{
m_pTransportLayer = new SIP_TransportLayer(this);
m_pTransactionLayer = new SIP_TransactionLayer(this);
m_pNonceManager = new Auth_HttpDigest_NonceManager();
m_pProxyServers = new List<SIP_Uri>();
m_pRegistrations = new List<SIP_UA_Registration>();
m_pCredentials = new List<NetworkCredential>();
m_RegisterCallID = SIP_t_CallID.CreateCallID();
m_pAllow = new List<string>();
m_pAllow.AddRange(new string[]{"INVITE","ACK","CANCEL","BYE","MESSAGE"});
m_pSupported = new List<string>();
m_pLogger = new Logger();
m_pDnsClient = new Dns_Client();
}
/// <summary>
/// Cleans up any resource being used.
/// </summary>
public void Dispose()
{
lock(m_pLock){
if(this.State == DNS_ClientTransactionState.Disposed){
return;
}
SetState(DNS_ClientTransactionState.Disposed);
m_pTimeoutTimer.Dispose();
m_pTimeoutTimer = null;
m_pOwner = null;
m_pResponse = null;
this.StateChanged = null;
this.Timeout = null;
}
}
/// <summary>
/// Gets host name. If fails returns ip address.
/// </summary>
/// <param name="ip">IP address which to reverse lookup.</param>
/// <returns>Returns host name of specified IP address.</returns>
/// <exception cref="ArgumentNullException">Is raised when <b>ip</b> is null.</exception>
public static string GetHostName(IPAddress ip)
{
if(ip == null){
throw new ArgumentNullException("ip");
}
string retVal = ip.ToString();
try{
Dns_Client dns = new Dns_Client();
DnsServerResponse response = dns.Query(ip.ToString(),DNS_QType.PTR);
if(response.ResponseCode == DNS_RCode.NO_ERROR){
DNS_rr_PTR[] ptrs = response.GetPTRRecords();
if(ptrs.Length > 0){
retVal = ptrs[0].DomainName;
}
}
}
catch{
}
return retVal;
}
/// <summary>
/// Default constructor.
/// </summary>
public Relay_Server()
{
m_pQueues = new List<Relay_Queue>();
m_pSmartHosts = new CircleCollection<Relay_SmartHost>();
m_pDsnClient = new Dns_Client();
}
/// <summary>
/// Resolves host name to IP addresses.
/// </summary>
/// <param name="host">Host name or IP address.</param>
/// <returns>Return specified host IP addresses.</returns>
/// <exception cref="ArgumentNullException">Is raised when <b>host</b> is null.</exception>
public static IPAddress[] Resolve(string host)
{
if(host == null){
throw new ArgumentNullException("host");
}
// If hostName_IP is IP
try{
return new IPAddress[]{IPAddress.Parse(host)};
}
catch{
}
// This is probably NetBios name
if(host.IndexOf(".") == -1){
return System.Net.Dns.GetHostEntry(host).AddressList;
}
else{
// hostName_IP must be host name, try to resolve it's IP
using(Dns_Client dns = new Dns_Client()){
DnsServerResponse resp = dns.Query(host,DNS_QType.A);
if(resp.ResponseCode == DNS_RCode.NO_ERROR){
DNS_rr_A[] records = resp.GetARecords();
IPAddress[] retVal = new IPAddress[records.Length];
for(int i=0;i<records.Length;i++){
retVal[i] = records[i].IP;
}
return retVal;
}
else{
throw new Exception(resp.ResponseCode.ToString());
}
}
}
}
/// <summary>
/// Starts operation processing.
/// </summary>
/// <param name="dnsClient">DNS client.</param>
/// <returns>Returns true if asynchronous operation in progress or false if operation completed synchronously.</returns>
/// <exception cref="ArgumentNullException">Is raised when <b>dnsClient</b> is null reference.</exception>
internal bool Start(Dns_Client dnsClient)
{
if(dnsClient == null){
throw new ArgumentNullException("dnsClient");
}
SetState(AsyncOP_State.Active);
m_pHostEntries = new HostEntry[m_pHostNames.Length];
// Create look up operations for hosts. The "opList" copy array is needed because
// when we start asyn OP, m_pIpLookupQueue may be altered when OP completes.
Dictionary<int,GetHostAddressesAsyncOP> opList = new Dictionary<int,GetHostAddressesAsyncOP>();
for(int i=0;i<m_pHostNames.Length;i++){
GetHostAddressesAsyncOP op = new GetHostAddressesAsyncOP(m_pHostNames[i]);
m_pIpLookupQueue.Add(i,op);
opList.Add(i,op);
}
// Start operations.
foreach(KeyValuePair<int,GetHostAddressesAsyncOP> entry in opList){
// NOTE: We may not access "entry" in CompletedAsync, because next for loop reassigns this value.
int index = entry.Key;
// This event is raised when GetHostAddressesAsync completes asynchronously.
entry.Value.CompletedAsync += delegate(object s1,EventArgs<GetHostAddressesAsyncOP> e1){
GetHostAddressesCompleted(e1.Value,index);
};
// GetHostAddressesAsync completes synchronously.
if(!dnsClient.GetHostAddressesAsync(entry.Value)){
GetHostAddressesCompleted(entry.Value,index);
}
}
// Set flag rise CompletedAsync event flag. The event is raised when async op completes.
// If already completed sync, that flag has no effect.
lock(m_pLock){
m_RiseCompleted = true;
return m_State == AsyncOP_State.Active;
}
}
/// <summary>
/// Starts operation processing.
/// </summary>
/// <param name="dnsClient">DNS client.</param>
/// <returns>Returns true if asynchronous operation in progress or false if operation completed synchronously.</returns>
/// <exception cref="ArgumentNullException">Is raised when <b>dnsClient</b> is null reference.</exception>
internal bool Start(Dns_Client dnsClient)
{
if(dnsClient == null){
throw new ArgumentNullException("dnsClient");
}
SetState(AsyncOP_State.Active);
// Argument 'hostNameOrIP' is IP address.
if(Net_Utils.IsIPAddress(m_HostNameOrIP)){
m_pIPv4Addresses.Add(IPAddress.Parse(m_HostNameOrIP));
SetState(AsyncOP_State.Completed);
}
// This is probably NetBios name.
if(m_HostNameOrIP.IndexOf(".") == -1){
try{
// This callback is called when BeginGetHostAddresses method has completed.
AsyncCallback callback = delegate(IAsyncResult ar){
try{
foreach(IPAddress ip in System.Net.Dns.EndGetHostAddresses(ar)){
if(ip.AddressFamily == AddressFamily.InterNetwork){
m_pIPv4Addresses.Add(ip);
}
else{
m_pIPv6Addresses.Add(ip);
}
}
}
catch(Exception x){
m_pException = x;
}
SetState(AsyncOP_State.Completed);
};
// Start resolving host ip addresses.
System.Net.Dns.BeginGetHostAddresses(m_HostNameOrIP,callback,null);
}
catch(Exception x){
m_pException = x;
}
}
// Query A/AAAA records.
else{
#region A records transaction
DNS_ClientTransaction transaction_A = dnsClient.CreateTransaction(DNS_QType.A,m_HostNameOrIP,2000);
transaction_A.StateChanged += delegate(object s1,EventArgs<DNS_ClientTransaction> e1){
if(e1.Value.State == DNS_ClientTransactionState.Completed){
lock(m_pLock){
if(e1.Value.Response.ResponseCode != DNS_RCode.NO_ERROR){
m_pException = new DNS_ClientException(e1.Value.Response.ResponseCode);
}
else{
foreach(DNS_rr_A record in e1.Value.Response.GetARecords()){
m_pIPv4Addresses.Add(record.IP);
}
}
m_Counter++;
// Both A and AAAA transactions are completed, we are done.
if(m_Counter == 2){
SetState(AsyncOP_State.Completed);
}
}
}
};
transaction_A.Timeout += delegate(object s1,EventArgs e1){
lock(m_pLock){
m_pException = new IOException("DNS transaction timeout, no response from DNS server.");
m_Counter++;
// Both A and AAAA transactions are completed, we are done.
if(m_Counter == 2){
SetState(AsyncOP_State.Completed);
}
}
};
transaction_A.Start();
#endregion
#region AAAA records transaction
DNS_ClientTransaction transaction_AAAA = dnsClient.CreateTransaction(DNS_QType.AAAA,m_HostNameOrIP,2000);
transaction_AAAA.StateChanged += delegate(object s1,EventArgs<DNS_ClientTransaction> e1){
if(e1.Value.State == DNS_ClientTransactionState.Completed){
lock(m_pLock){
if(e1.Value.Response.ResponseCode != DNS_RCode.NO_ERROR){
m_pException = new DNS_ClientException(e1.Value.Response.ResponseCode);
}
else{
foreach(DNS_rr_AAAA record in e1.Value.Response.GetAAAARecords()){
m_pIPv6Addresses.Add(record.IP);
}
}
m_Counter++;
// Both A and AAAA transactions are completed, we are done.
if(m_Counter == 2){
SetState(AsyncOP_State.Completed);
}
}
}
};
transaction_AAAA.Timeout += delegate(object s1,EventArgs e1){
lock(m_pLock){
m_pException = new IOException("DNS transaction timeout, no response from DNS server.");
m_Counter++;
// Both A and AAAA transactions are completed, we are done.
if(m_Counter == 2){
SetState(AsyncOP_State.Completed);
}
}
};
transaction_AAAA.Start();
#endregion
}
// Set flag rise CompletedAsync event flag. The event is raised when async op completes.
// If already completed sync, that flag has no effect.
lock(m_pLock){
m_RiseCompleted = true;
return m_State == AsyncOP_State.Active;
}
}
/// <summary>
/// Stops this virtual server.
/// </summary>
public void Stop()
{
m_Running = false;
if(m_pDnsClient != null){
m_pDnsClient.Dispose();
m_pDnsClient = null;
}
if(m_pSmtpServer != null){
try{
m_pSmtpServer.Dispose();
}
catch{
}
m_pSmtpServer = null;
}
if(m_pPop3Server != null){
try{
m_pPop3Server.Dispose();
}
catch{
}
m_pPop3Server = null;
}
if(m_pImapServer != null){
try{
m_pImapServer.Dispose();
}
catch{
}
m_pImapServer = null;
}
if(m_pRelayServer != null){
try{
m_pRelayServer.Dispose();
}
catch{
}
m_pRelayServer = null;
}
if(m_pFetchServer != null){
try{
m_pFetchServer.Dispose();
}
catch{
}
m_pFetchServer = null;
}
if(m_pSipServer != null){
try{
m_pSipServer.Stack.Stop();
}
catch{
}
m_pSipServer = null;
}
if(m_pTimer != null){
try{
m_pTimer.Dispose();
}
catch{
}
m_pTimer = null;
}
if(m_pRecycleBinManager != null){
try{
m_pRecycleBinManager.Dispose();
}
catch{
}
m_pRecycleBinManager = null;
}
if(m_pBadLoginManager != null){
try{
m_pBadLoginManager.Dispose();
}
catch{
}
m_pBadLoginManager = null;
}
}
/// <summary>
/// Is called when smart hosts ip addresses resolve operation has completed.
/// </summary>
/// <param name="op">Asynchronous operation.</param>
/// <exception cref="ArgumentNullException">Is raised when <b>op</b> is null reference.</exception>
private void SmartHostsResolveCompleted(Dns_Client.GetHostsAddressesAsyncOP op)
{
if(op == null){
throw new ArgumentNullException("op");
}
if(op.Error != null){
LogText("Failed to resolve relay smart host(s) ip addresses with error: " + op.Error.Message + ".");
Dispose(op.Error);
}
else{
for(int i=0;i<op.HostEntries.Length;i++){
Relay_SmartHost smartHost = m_pSmartHosts[i];
foreach(IPAddress ip in op.HostEntries[i].Addresses){
m_pTargets.Add(new Relay_Target(smartHost.Host,new IPEndPoint(ip,smartHost.Port),smartHost.SslMode,smartHost.UserName,smartHost.Password));
}
}
BeginConnect();
}
op.Dispose();
}
/// <summary>
/// Is called when email domain target servers resolve operation has completed.
/// </summary>
/// <param name="to">RCPT TO: address.</param>
/// <param name="op">Asynchronous operation.</param>
/// <exception cref="ArgumentNullException">Is raised when <b>to</b> or <b>op</b> is null reference.</exception>
private void EmailHostsResolveCompleted(string to,Dns_Client.GetEmailHostsAsyncOP op)
{
if(to == null){
throw new ArgumentNullException("to");
}
if(op == null){
throw new ArgumentNullException("op");
}
if(op.Error != null){
LogText("Failed to resolve email domain for email address '" + to + "' with error: " + op.Error.Message + ".");
Dispose(op.Error);
}
else{
StringBuilder buf = new StringBuilder();
foreach(HostEntry host in op.Hosts){
foreach(IPAddress ip in host.Addresses){
m_pTargets.Add(new Relay_Target(host.HostName,new IPEndPoint(ip,25)));
}
buf.Append(host.HostName + " ");
}
LogText("Resolved to following email hosts: (" + buf.ToString().TrimEnd() + ").");
BeginConnect();
}
op.Dispose();
}
/// <summary>
/// Cleans up any resources being used.
/// </summary>
public void Dispose()
{
if(m_IsDisposed){
return;
}
try{
if(m_IsRunning){
Stop();
}
}
catch{
}
m_IsDisposed = true;
// Release events.
this.Error = null;
this.SessionCompleted = null;
m_pQueues = null;
m_pSmartHosts = null;
m_pDsnClient.Dispose();
m_pDsnClient = null;
}
/// <summary>
/// Starts operation processing.
/// </summary>
/// <param name="dnsClient">DNS client.</param>
/// <returns>Returns true if asynchronous operation in progress or false if operation completed synchronously.</returns>
/// <exception cref="ArgumentNullException">Is raised when <b>dnsClient</b> is null reference.</exception>
internal bool Start(Dns_Client dnsClient)
{
if(dnsClient == null){
throw new ArgumentNullException("dnsClient");
}
SetState(AsyncOP_State.Active);
/* RFC 5321 5.
The lookup first attempts to locate an MX record associated with the
name. If a CNAME record is found, the resulting name is processed as
if it were the initial name.
If no MX records are found, but an A RR is found, the A RR is treated as if it
was associated with an implicit MX RR, with a preference of 0, pointing to that host.
*/
try{
LookupMX(dnsClient,m_Domain,false);
}
catch(Exception x){
m_pException = x;
SetState(AsyncOP_State.Completed);
}
// Set flag rise CompletedAsync event flag. The event is raised when async op completes.
// If already completed sync, that flag has no effect.
lock(m_pLock){
m_RiseCompleted = true;
return m_State == AsyncOP_State.Active;
}
}
/// <summary>
/// Starts looking up MX records for specified domain.
/// </summary>
/// <param name="dnsClient">DNS client.</param>
/// <param name="domain">Domain name.</param>
/// <param name="domainIsCName">If true domain name is CNAME(alias).</param>
/// <exception cref="ArgumentNullException">Is riased when <b>dnsClient</b> or <b>domain</b> is null reference.</exception>
private void LookupMX(Dns_Client dnsClient,string domain,bool domainIsCName)
{
if(dnsClient == null){
throw new ArgumentNullException("dnsClient");
}
if(domain == null){
throw new ArgumentNullException("domain");
}
// Try to get MX records.
DNS_ClientTransaction transaction_MX = dnsClient.CreateTransaction(DNS_QType.MX,domain,2000);
transaction_MX.StateChanged += delegate(object s1,EventArgs<DNS_ClientTransaction> e1){
try{
if(e1.Value.State == DNS_ClientTransactionState.Completed){
// No errors.
if(e1.Value.Response.ResponseCode == DNS_RCode.NO_ERROR){
List<DNS_rr_MX> mxRecords = new List<DNS_rr_MX>();
foreach(DNS_rr_MX mx in e1.Value.Response.GetMXRecords()){
// Skip invalid MX records.
if(string.IsNullOrEmpty(mx.Host)){
}
else{
mxRecords.Add(mx);
}
}
// Use MX records.
if(mxRecords.Count > 0){
m_pHosts = new HostEntry[mxRecords.Count];
// Create name to index map, so we can map asynchronous A/AAAA lookup results back to MX priority index.
Dictionary<string,int> name_to_index_map = new Dictionary<string,int>();
List<string> lookupQueue = new List<string>();
// Process MX records.
for(int i=0;i<m_pHosts.Length;i++){
DNS_rr_MX mx = mxRecords[i];
IPAddress[] ips = Get_A_or_AAAA_FromResponse(mx.Host,e1.Value.Response);
// No A or AAAA records in addtional answers section for MX, we need todo new query for that.
if(ips.Length == 0){
name_to_index_map[mx.Host] = i;
lookupQueue.Add(mx.Host);
}
else{
m_pHosts[i] = new HostEntry(mx.Host,ips,null);
}
}
// We have MX records which A or AAAA records not provided in DNS response, lookup them.
if(lookupQueue.Count > 0){
GetHostsAddressesAsyncOP op = new GetHostsAddressesAsyncOP(lookupQueue.ToArray(),true);
// This event is raised when lookup completes asynchronously.
op.CompletedAsync += delegate(object s2,EventArgs<GetHostsAddressesAsyncOP> e2){
LookupCompleted(op,name_to_index_map);
};
// Lookup completed synchronously.
if(!dnsClient.GetHostsAddressesAsync(op)){
LookupCompleted(op,name_to_index_map);
}
}
// All MX records resolved.
else{
SetState(AsyncOP_State.Completed);
}
}
// Use CNAME as initial domain name.
else if(e1.Value.Response.GetCNAMERecords().Length > 0){
if(domainIsCName){
m_pException = new Exception("CNAME to CNAME loop dedected.");
SetState(AsyncOP_State.Completed);
}
else{
LookupMX(dnsClient,e1.Value.Response.GetCNAMERecords()[0].Alias,true);
}
}
// Use domain name as MX.
else{
m_pHosts = new HostEntry[1];
// Create name to index map, so we can map asynchronous A/AAAA lookup results back to MX priority index.
Dictionary<string,int> name_to_index_map = new Dictionary<string,int>();
name_to_index_map.Add(domain,0);
GetHostsAddressesAsyncOP op = new GetHostsAddressesAsyncOP(new string[]{domain});
// This event is raised when lookup completes asynchronously.
op.CompletedAsync += delegate(object s2,EventArgs<GetHostsAddressesAsyncOP> e2){
LookupCompleted(op,name_to_index_map);
};
// Lookup completed synchronously.
if(!dnsClient.GetHostsAddressesAsync(op)){
LookupCompleted(op,name_to_index_map);
}
}
}
// DNS server returned error, just return error.
else{
m_pException = new DNS_ClientException(e1.Value.Response.ResponseCode);
SetState(AsyncOP_State.Completed);
}
}
transaction_MX.Timeout += delegate(object s2,EventArgs e2){
m_pException = new IOException("DNS transaction timeout, no response from DNS server.");
SetState(AsyncOP_State.Completed);
};
}
catch(Exception x){
m_pException = x;
SetState(AsyncOP_State.Completed);
}
};
transaction_MX.Start();
}
public static string[] GetDomainHosts(string domain)
{
if(domain == null){
throw new ArgumentNullException("domain");
}
if(string.IsNullOrEmpty(domain)){
throw new ArgumentException("Invalid argument 'domain' value, you need to specify domain value.");
}
// We have email address, parse domain.
if(domain.IndexOf("@") > -1){
domain = domain.Substring(domain.IndexOf('@') + 1);
}
List<string> retVal = new List<string>();
// Get MX records.
using(Dns_Client dns = new Dns_Client()){
DnsServerResponse response = dns.Query(domain,DNS_QType.MX);
if(response.ResponseCode == DNS_RCode.NO_ERROR){
foreach(DNS_rr_MX mx in response.GetMXRecords()){
// Block invalid MX records.
if(!string.IsNullOrEmpty(mx.Host)){
retVal.Add(mx.Host);
}
}
}
else{
throw new DNS_ClientException(response.ResponseCode);
}
}
/* RFC 2821 5.
If no MX records are found, but an A RR is found, the A RR is treated as if it
was associated with an implicit MX RR, with a preference of 0, pointing to that host.
*/
if(retVal.Count == 0){
retVal.Add(domain);
}
return retVal.ToArray();
}
/// <summary>
/// Starts this virtual server.
/// </summary>
public void Start()
{
if(m_Running){
return;
}
m_Running = true;
m_pDnsClient = new Dns_Client();
m_pSmtpServer = new SMTP_Server();
m_pSmtpServer.Error += new LumiSoft.Net.ErrorEventHandler(OnServer_SysError);
m_pSmtpServer.SessionCreated += new EventHandler<TCP_ServerSessionEventArgs<SMTP_Session>>(m_pSmtpServer_SessionCreated);
m_pPop3Server = new POP3_Server();
m_pPop3Server.Error += new LumiSoft.Net.ErrorEventHandler(OnServer_SysError);
m_pPop3Server.SessionCreated += new EventHandler<TCP_ServerSessionEventArgs<POP3_Session>>(m_pPop3Server_SessionCreated);
m_pImapServer = new IMAP_Server();
m_pImapServer.Error += new LumiSoft.Net.ErrorEventHandler(OnServer_SysError);
m_pImapServer.SessionCreated += new EventHandler<TCP_ServerSessionEventArgs<IMAP_Session>>(m_pImapServer_SessionCreated);
m_pRelayServer = new RelayServer(this);
m_pRelayServer.DnsClient = m_pDnsClient;
m_pFetchServer = new FetchPop3(this,m_pApi);
m_pSipServer = new SIP_Proxy(new SIP_Stack());
m_pSipServer.Authenticate += new SIP_AuthenticateEventHandler(m_pSipServer_Authenticate);
m_pSipServer.IsLocalUri += new SIP_IsLocalUriEventHandler(m_pSipServer_IsLocalUri);
m_pSipServer.AddressExists += new SIP_AddressExistsEventHandler(m_pSipServer_AddressExists);
m_pSipServer.Registrar.CanRegister += new SIP_CanRegisterEventHandler(m_pSipServer_CanRegister);
m_pSipServer.Stack.Error += new EventHandler<ExceptionEventArgs>(m_pSipServer_Error);
m_pRecycleBinManager = new RecycleBinManager(m_pApi);
m_pBadLoginManager = new BadLoginManager();
m_pTimer = new System.Timers.Timer();
m_pTimer.Interval = 15000;
m_pTimer.Elapsed += new System.Timers.ElapsedEventHandler(m_pTimer_Elapsed);
m_pTimer.Enabled = true;
LoadSettings();
}