dnsapi.cs

A project written in C# sends email without smtp server. It queries dns server for mx records and se

// $Id: DNSAPI.cs,v 1.6 2006/08/07 09:59:51 ethem Exp $
namespace Erle
{
	using System;
	using System.Net;
	using System.Net.Sockets;
	using System.Collections;
	using System.Runtime.InteropServices;
	using NetDns = System.Net.Dns;
	using MxRecord = Erle.DnsMail.MxRecord;
	using MxRecordComparer = Erle.DnsMail.MxRecordComparer;

	public sealed class DNSAPI
	{
		private DNSAPI() { }
		static DNSAPI()
		{
			DnsCache.DeletedAll += new EventHandler(DeletedAll);
		}

		#region DeletedAll
		private static void DeletedAll(object sender, EventArgs e)
		{
			dnsServers = null;
			localHost = null;
			hello = null;

			GC.Collect();
		}
		#endregion

		#region LocalHost
		private static String localHost;
		public static String LocalHost
		{
			get
			{
				if (localHost == null)
					localHost = NetDns.GetHostName();

				return localHost;
			}
		}
		#endregion

		#region HelloHost
		private static String hello;
		public static String HelloHost
		{
			get
			{
				if (hello == null)
					hello = NetDns.GetHostByAddress(NetDns.GetHostByName(LocalHost).AddressList[0]).HostName;

				return hello;
			}
		}
		#endregion

		#region DnsServers
		private static String[] dnsServers;
		public static String[] DnsServers
		{
			get
			{
				if (dnsServers == null)
					dnsServers = UnsafeNativeMethods.FindDnsServers();

				return dnsServers;
			}
		}
		#endregion

		#region Resolve Delegate
		private delegate MxRecord[] MxRecordsDelegate(string domain);
		private static readonly MxRecordsDelegate resolve = new MxRecordsDelegate(GetMxRecords);
		public static IAsyncResult BeginGetMxRecords(string domain, AsyncCallback callback, Object state)
		{
			if (domain == null)
				throw new ArgumentNullException("domain");

			return resolve.BeginInvoke(domain, callback, state);
		}

		public static MxRecord[] EndGetMxRecords(IAsyncResult result)
		{
			if (result == null)
				throw new ArgumentNullException("result");

			if (!result.IsCompleted)
				result.AsyncWaitHandle.WaitOne();

			return resolve.EndInvoke(result);
		}
		#endregion

		#region GetMxRecords
		public static MxRecord[] GetMxRecords(String domain)
		{
			if (domain == null || domain == String.Empty)
				return null;

			MxRecord[] cache = DnsCache.GetFromCache(domain);
			if (cache != null && cache.Length > 0)
				return (cache); // struct-copy

			IntPtr pQuery = IntPtr.Zero;
			UInt32 status = UnsafeNativeMethods.DnsQuery(
				domain,
				STRUCTURES.DNS_TYPE_MX,
				STRUCTURES.DNS_QUERY_STANDARD,
				IntPtr.Zero,
				ref pQuery,
				IntPtr.Zero
			);

			if (status == STRUCTURES.SUCCESS && pQuery != IntPtr.Zero)
			{
				try
				{
					STRUCTURES.DNS_RECORD dnsRec;
					ArrayList tmp = new ArrayList();
					for (IntPtr pDnsRec = pQuery; pDnsRec != IntPtr.Zero; pDnsRec = dnsRec.pNext)
					{
						dnsRec = (STRUCTURES.DNS_RECORD)Marshal.PtrToStructure(pDnsRec, typeof(STRUCTURES.DNS_RECORD));
						if (dnsRec.wType != STRUCTURES.DNS_TYPE_MX)
						{
							break; // no additional record
						}
						IntPtr pMxData = new IntPtr(pDnsRec.ToInt32() + STRUCTURES.DNS_RECORD.SIZE); // jump to mxrecord
						STRUCTURES.DNS_MX_DATA mxdata = (STRUCTURES.DNS_MX_DATA)Marshal.PtrToStructure(pMxData, typeof(STRUCTURES.DNS_MX_DATA));
						tmp.Add(new MxRecord(String.Copy(mxdata.pNameExchange), (short)mxdata.wPreference));
					}

					if (tmp.Count > 0)
					{
						MxRecord[] mxs = (MxRecord[])tmp.ToArray(typeof(MxRecord));
						if (mxs.Length > 1)
							Array.Sort(mxs, 0, mxs.Length, MxRecordComparer.Default);

						// Resolve
						bool err = false;
						for (int i = 0; i < mxs.Length; i++)
						{
							try
							{
								IPAddress[] ipx = NetDns.GetHostByName(mxs[i].NameExchange).AddressList;

								if (ipx != null && ipx.Length != 0)
								{
									foreach (IPAddress ipadr in ipx)
										mxs[i] += ipadr;
								}
							}
							catch (SocketException se)
							{
								if (11004 != se.ErrorCode)
									throw; // The requested name is valid, but no data of the requested type was found
							}
							catch
							{
								err = true;
							}
						}

						if (!err)
							DnsCache.AddToCache(domain, mxs);

						tmp.Clear();
						return mxs;
					}
				}
				finally
				{
					UnsafeNativeMethods.DnsRecordListFree(pQuery, 1);
				}
			}
			else
			{
				// TO DO
				// int win32error = Marshal.GetLastWin32Error();
			}
			return null;
		}
		#endregion
	}
};