unsafenativemethods.cs

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

// $Id: UnsafeNativeMethods.cs,v 1.5 2006/08/07 08:25:14 ethem Exp $
namespace Erle
{
	using System;
	using System.Security;
	using System.Collections;
	using System.Security.Permissions;
	using System.Runtime.InteropServices;

	internal sealed class STRUCTURES
	{
		private STRUCTURES() { }
		internal const UInt32 SUCCESS = 0;
		internal const UInt32 DNS_QUERY_STANDARD = 0;
		internal const UInt16 DNS_TYPE_MX = 15;

		#region DNS_MX_DATA
		/// <summary>
		/// DNS_MX_DATA
		/// </summary>
		[StructLayout(LayoutKind.Sequential)]
		internal struct DNS_MX_DATA
		{
			internal string pNameExchange;
			internal UInt16 wPreference;
			internal UInt16 wPad;
		}
		#endregion

		#region DNS_RECORD
		/// <summary>
		/// DNS_RECORD
		/// </summary>
		[StructLayout(LayoutKind.Sequential)]
		internal struct DNS_RECORD
		{
			internal IntPtr pNext;
			internal String pName;
			[MarshalAs(UnmanagedType.U2)]
			internal UInt16 wType;
			[MarshalAs(UnmanagedType.U2)]
			internal UInt16 wDataLength;
			[MarshalAs(UnmanagedType.U4)]
			internal UInt32 flags;
			[MarshalAs(UnmanagedType.U4)]
			internal UInt32 dwTtl;
			[MarshalAs(UnmanagedType.U4)]
			internal UInt32 dwReserved;
			internal static readonly int SIZE = Marshal.SizeOf(typeof(DNS_RECORD));
		}
		#endregion

		#region FIXED_INFO
		/// <summary>
		/// FIXED_INFO
		/// </summary>
		[StructLayout(LayoutKind.Sequential)]
		internal struct FIXED_INFO
		{
			[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 132)]
			internal string HostName;
			[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 132)]
			internal string DomainName;
			internal IntPtr CurrentDnsServer; // pointer to IP_ADDR_STRING
			internal IP_ADDR_STRING DnsServerList;
			internal UInt32 NodeType;
			[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
			internal string ScopeId;
			internal bool EnableRouting;
			internal bool EnableProxy;
			internal bool EnableDns;
		}
		#endregion

		#region IP_ADDR_STRING
		/// <summary>
		/// IP_ADDR_STRING
		/// </summary>
		[StructLayout(LayoutKind.Sequential)]
		internal struct IP_ADDR_STRING
		{
			internal IntPtr Next;
			[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 16)]
			internal string IpAddress;
			[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 16)]
			internal string IpMask;
			internal uint Context;
		}
		#endregion
	}

	[SuppressUnmanagedCodeSecurityAttribute()]
	internal sealed class UnsafeNativeMethods
	{
		private UnsafeNativeMethods() { }
		private const String DNS_API_DLL = "dnsapi.dll";
		private const String DNS_API_QUERY = "DnsQuery_A";
		private const String IP_HELP_API_DLL = "iphlpapi.dll";
		private const UInt32 ERROR_BUFFER_OVERFLOW = (UInt32)111;

		#region DnsQuery
		/// <summary>
		/// DnsQuery
		/// </summary>
		[DllImport(DNS_API_DLL, EntryPoint = DNS_API_QUERY, CharSet = CharSet.Auto, SetLastError = true)]
		internal static extern UInt32 DnsQuery(
			[In, MarshalAs(UnmanagedType.LPStr)] String lpstrName,
			[In, MarshalAs(UnmanagedType.U2)] UInt16 wType,
			[In, MarshalAs(UnmanagedType.U4)] UInt32 fOptions,
			[In] IntPtr aipServers,
			[In, Out] ref IntPtr ppQueryResults,
			[In, Out] IntPtr pReserved
		);
		#endregion

		#region DnsRecordListFree
		/// <summary>
		/// DnsRecordListFree
		/// </summary>
		[DllImport(DNS_API_DLL)]
		internal static extern void DnsRecordListFree(
			[In, Out]	IntPtr pRecordList,
			[In]		UInt16 FreeType
		);
		#endregion

		#region GetNetworkParams
		/// <summary>
		/// GetNetworkParams
		/// </summary>
		[DllImport(IP_HELP_API_DLL, CharSet = CharSet.Auto, SetLastError = true)]
		private static extern UInt32 GetNetworkParams(
			IntPtr pMemory,
			ref Int32 pOutBufLen
		);
		#endregion

		#region FindDnsServers
		internal static String[] FindDnsServers()
		{
			ArrayList iptemp;
			Int32 pOutBufLen = 0;

			STRUCTURES.FIXED_INFO fi;
			STRUCTURES.IP_ADDR_STRING serv;

			UInt32 status = GetNetworkParams(IntPtr.Zero, ref pOutBufLen);
			if (status != ERROR_BUFFER_OVERFLOW || pOutBufLen == 0)
				throw new Exception("GetNetworkParams(0,&size)");

			IntPtr pMemory = Marshal.AllocHGlobal(pOutBufLen);
			try
			{
				status = GetNetworkParams(pMemory, ref pOutBufLen);
				if (status != STRUCTURES.SUCCESS)
					throw new Exception("GetNetworkParams(&mem,&size)");

				iptemp = new ArrayList();
				fi = (STRUCTURES.FIXED_INFO)Marshal.PtrToStructure(pMemory, typeof(STRUCTURES.FIXED_INFO));
				if (fi.DnsServerList.IpAddress != null && fi.DnsServerList.IpAddress != String.Empty)
				{
					iptemp.Add(String.Copy(fi.DnsServerList.IpAddress));
					IntPtr pAddrStr = fi.DnsServerList.Next;
					int maxloop = 10;
					while ((pAddrStr != IntPtr.Zero) && (--maxloop > 0))
					{
						serv = (STRUCTURES.IP_ADDR_STRING)Marshal.PtrToStructure(pAddrStr, typeof(STRUCTURES.IP_ADDR_STRING));
						if (serv.IpAddress != null && serv.IpAddress != String.Empty)
							iptemp.Add(String.Copy(serv.IpAddress));

						Marshal.DestroyStructure(pAddrStr, typeof(STRUCTURES.IP_ADDR_STRING));
						pAddrStr = serv.Next;
					}
				}
				Marshal.DestroyStructure(pMemory, typeof(STRUCTURES.FIXED_INFO));
				if (iptemp.Count > 0)
				{
					String[] servers = (String[])iptemp.ToArray(typeof(String));
					iptemp.Clear();
					return servers;
				}
				else
					return new string[0] { }; //length=0
			}
			finally
			{
				if (pMemory != IntPtr.Zero)
				{
					Marshal.FreeHGlobal(pMemory);
					pMemory = IntPtr.Zero;
				}
				iptemp = null;
			}
		}
		#endregion
	}

	internal unsafe sealed class UnsafeOpenSsl
	{
		private UnsafeOpenSsl() { }
		private const String LIB_EAY = @"libeay32.dll";
		private const String LIB_SSL = @"ssleay32.dll";

		[DllImport(LIB_SSL)]
		internal static extern int SSL_library_init();
		[DllImport(LIB_SSL)]
		internal static extern void SSL_load_error_strings();
		[DllImport(LIB_SSL)]
		internal static extern IntPtr TLSv1_method();
		[DllImport(LIB_SSL)]
		internal static extern IntPtr SSL_CTX_new(IntPtr method);
		[DllImport(LIB_SSL)]
		internal static extern void SSL_CTX_free(IntPtr ctx);
		[DllImport(LIB_SSL)]
		internal static extern IntPtr SSL_new(IntPtr ctx);
		[DllImport(LIB_SSL)]
		internal static extern void SSL_free(IntPtr ssl);
		[DllImport(LIB_SSL)]
		internal static extern int SSL_shutdown(IntPtr ssl);
		[DllImport(LIB_SSL)]
		internal static extern int SSL_set_fd(IntPtr ssl, IntPtr sockHandle);
		[DllImport(LIB_SSL)]
		internal static extern void SSL_set_quiet_shutdown(IntPtr ssl, int mode);
		[DllImport(LIB_SSL)]
		internal static extern int SSL_ctrl(IntPtr ssl, int cmd, int larg, IntPtr parg);
		[DllImport(LIB_SSL)]
		internal static extern int SSL_connect(IntPtr ssl);
		[DllImport(LIB_SSL)]
		internal static extern int SSL_read(IntPtr ssl, byte* buf, int num);
		[DllImport(LIB_SSL)]
		internal static extern int SSL_write(IntPtr ssl, byte* buf, int num);
		[DllImport(LIB_SSL)]
		internal static extern int SSL_peek(IntPtr ssl, byte* buf, int num);
		[DllImport(LIB_SSL)]
		internal static extern IntPtr SSL_get_peer_certificate(IntPtr ssl);
		[DllImport(LIB_SSL)]
		internal static extern int SSL_get_error(IntPtr ssl, int ret);

		[DllImport(LIB_EAY)]
		internal static extern uint SSLeay();
		[DllImport(LIB_EAY)]
		internal static extern int ERR_get_error();
		[DllImport(LIB_EAY)]
		internal static extern int ERR_peek_error();
		[DllImport(LIB_EAY)]
		internal static extern String ERR_error_string_n(int e, System.Text.StringBuilder sb, int l);
		[DllImport(LIB_EAY)]
		internal static extern void X509_free(IntPtr x509);
		[DllImport(LIB_EAY)]
		internal static extern int i2d_X509(IntPtr cer, byte** ppOut);
	}
};