internal void GetExtendedUdpTable()
{
int AF_INET = 2;
int buffSize = 20000;
byte[] buffer = new byte[buffSize];
int res = GetExtendedUdpTable(buffer, out buffSize, true, AF_INET, UDP_TABLE_CLASS.UDP_TABLE_OWNER_PID, 0);
if (res != NO_ERROR)
{
throw new InvalidOperationException("Error get extended udp table");
}
MIB_UDPTABLE_OWNER_PID udpExtendedTable = new MIB_UDPTABLE_OWNER_PID();
int nOffset = 0;
udpExtendedTable.dwNumEntries = Convert.ToInt32(buffer[nOffset]);
nOffset += 4;
udpExtendedTable.table = new MIB_UDPROW_OWNER_PID[udpExtendedTable.dwNumEntries];
for (int i = 0; i < udpExtendedTable.dwNumEntries; i++)
{
udpExtendedTable.table[i].Local = BufferToIPEndPoint(buffer, ref nOffset, false);
udpExtendedTable.table[i].dwOwningPid = BufferToInt(buffer, ref nOffset);
udpExtendedTable.table[i].ProcessName = GetProcessName(udpExtendedTable.table[i].dwOwningPid);
}
}
//return the MIB_UDPROW_OWNER_PID array
public MIB_UDPROW_OWNER_PID[] GetAllUdpConnections()
{
MIB_UDPROW_OWNER_PID[] tTable;
int AF_INET = 2; // IP_v4
int buffSize = 0;
// what the size of the memory we need to allocate for the table?
uint ret = GetExtendedUdpTable(IntPtr.Zero, ref buffSize, true, AF_INET, UDP_TABLE_CLASS.UDP_TABLE_OWNER_PID, 0);
//set pointer to buffer
IntPtr buffTable = Marshal.AllocHGlobal(buffSize);
try
{
//getting the buffer
ret = GetExtendedUdpTable(buffTable, ref buffSize, true, AF_INET, UDP_TABLE_CLASS.UDP_TABLE_OWNER_PID, 0);
if (ret != 0)
{
return(null);
}
//convert pointer to MIB_UDPTABLE_OWNER_PID pointer
MIB_UDPTABLE_OWNER_PID tab = (MIB_UDPTABLE_OWNER_PID)Marshal.PtrToStructure(buffTable, typeof(MIB_UDPTABLE_OWNER_PID));
IntPtr rowPtr = (IntPtr)((long)buffTable + Marshal.SizeOf(tab.dwNumEntries));
tTable = new MIB_UDPROW_OWNER_PID[tab.dwNumEntries];
//reading the row from buffer using next position pointer
//size of MIB_UDPROW_OWNER_PID
for (int i = 0; i < tab.dwNumEntries; i++)
{
//convert pointer to MIB_UDPROW_OWNER_PID pointer
MIB_UDPROW_OWNER_PID udpRow = (MIB_UDPROW_OWNER_PID)Marshal.PtrToStructure(rowPtr, typeof(MIB_UDPROW_OWNER_PID));
//save row in table
tTable[i] = udpRow;
//go to the next entry.
rowPtr = (IntPtr)((long)rowPtr + Marshal.SizeOf(udpRow));
}
}
finally
{
// clear buffer
Marshal.FreeHGlobal(buffTable);
}
return(tTable);
}
//public TcpRow[] GetAllTcpConnections()
public static MIB_UDPROW_OWNER_PID[] GetAllUdpConnections()
{
if (getAllUdpConnections_cached == null || getAllUdpConnections_cached_lastTime + new TimeSpan(0, 0, 1) < DateTime.Now)
{
MIB_UDPROW_OWNER_PID[] tTable;
int AF_INET = 2; // IP_v4
int buffSize = 0;
// how much memory do we need?
uint ret = GetExtendedUdpTable(IntPtr.Zero, ref buffSize, true, AF_INET, UDP_TABLE_CLASS.UDP_TABLE_OWNER_PID);
IntPtr buffTable = Marshal.AllocHGlobal(buffSize);
try
{
ret = GetExtendedUdpTable(buffTable, ref buffSize, true, AF_INET, UDP_TABLE_CLASS.UDP_TABLE_OWNER_PID);
if (ret != 0)
{
return(new MIB_UDPROW_OWNER_PID[0]);
}
// get the number of entries in the table
//MibTcpTable tab = (MibTcpTable)Marshal.PtrToStructure(buffTable, typeof(MibTcpTable));
MIB_UDPTABLE_OWNER_PID tab = (MIB_UDPTABLE_OWNER_PID)Marshal.PtrToStructure(buffTable, typeof(MIB_UDPTABLE_OWNER_PID));
//IntPtr rowPtr = (IntPtr)((long)buffTable + Marshal.SizeOf(tab.numberOfEntries) );
IntPtr rowPtr = (IntPtr)((long)buffTable + Marshal.SizeOf(tab.dwNumEntries));
// buffer we will be returning
//tTable = new TcpRow[tab.numberOfEntries];
tTable = new MIB_UDPROW_OWNER_PID[tab.dwNumEntries];
//for (int i = 0; i < tab.numberOfEntries; i++)
for (int i = 0; i < tab.dwNumEntries; i++)
{
//MibTcpRow_Owner_Pid tcpRow = (MibTcpRow_Owner_Pid)Marshal.PtrToStructure(rowPtr, typeof(MibTcpRow_Owner_Pid));
MIB_UDPROW_OWNER_PID tcpRow = (MIB_UDPROW_OWNER_PID)Marshal.PtrToStructure(rowPtr, typeof(MIB_UDPROW_OWNER_PID));
//tTable[i] = new TcpRow(tcpRow);
tTable[i] = tcpRow;
rowPtr = (IntPtr)((long)rowPtr + Marshal.SizeOf(tcpRow)); // next entry
}
}
finally
{
// Free the Memory
Marshal.FreeHGlobal(buffTable);
}
getAllUdpConnections_cached = tTable;
getAllUdpConnections_cached_lastTime = DateTime.Now;
}
return(getAllUdpConnections_cached);
}
public static List <UdpRecordPid> GetAllUdpConnections()
{
int AF_INET = 2; // IP_v4
int buffSize = 0;
// getting the memory size needed
uint val = GetExtendedUdpTable(IntPtr.Zero, ref buffSize, true, AF_INET, UDP_TABLE_CLASS.UDP_TABLE_OWNER_PID, 0);
if (val != 0 && val != 122)
{
throw new Exception("invalid size " + val);
}
IntPtr buffTable = Marshal.AllocHGlobal(buffSize);
List <UdpRecordPid> lstRecords = new List <UdpRecordPid>();
try
{
val = GetExtendedUdpTable(buffTable, ref buffSize, true, AF_INET, UDP_TABLE_CLASS.UDP_TABLE_OWNER_PID, 0);
if (val != 0)
{
throw new Exception("ivalid data " + val);
}
// get the number of entries in the table
MIB_UDPTABLE_OWNER_PID udpTable = (MIB_UDPTABLE_OWNER_PID)Marshal.PtrToStructure(buffTable, typeof(MIB_UDPTABLE_OWNER_PID));
IntPtr rowPtr = (IntPtr)((long)buffTable + Marshal.SizeOf(udpTable.dwNumEntries));
for (int i = 0; i < udpTable.dwNumEntries; i++)
{
MIB_UDPROW_OWNER_PID udpRow = (MIB_UDPROW_OWNER_PID)Marshal.PtrToStructure(rowPtr, typeof(MIB_UDPROW_OWNER_PID));
lstRecords.Add(new UdpRecordPid(
new IPAddress(udpRow.localAddr),
BitConverter.ToUInt16(new byte[2] {
udpRow.localPort2, udpRow.localPort1
}, 0), // reverse order
udpRow.owningPid));
// next record
rowPtr = (IntPtr)((long)rowPtr + Marshal.SizeOf(udpRow));
}
}
finally
{
Marshal.FreeHGlobal(buffTable);
}
return(lstRecords.Distinct().ToList <UdpRecordPid>());
}
private static Connection[] GetUDP()
{
MIB_UDPROW_OWNER_PID[] tTable;
int AF_INET = 2; // IP_v4
int buffSize = 0;
uint ret = GetExtendedUdpTable(IntPtr.Zero, ref buffSize, true, AF_INET, UDP_TABLE_CLASS.UDP_TABLE_OWNER_PID, 0);
IntPtr buffTable = Marshal.AllocHGlobal(buffSize);
try
{
ret = GetExtendedUdpTable(buffTable, ref buffSize, true, AF_INET, UDP_TABLE_CLASS.UDP_TABLE_OWNER_PID, 0);
if (ret != 0)
{//none found
Connection[] con = new Connection[0];
return(con);
}
MIB_UDPTABLE_OWNER_PID tab = (MIB_UDPTABLE_OWNER_PID)Marshal.PtrToStructure(buffTable, typeof(MIB_UDPTABLE_OWNER_PID));
IntPtr rowPtr = (IntPtr)((long)buffTable + Marshal.SizeOf(tab.dwNumEntries));
tTable = new MIB_UDPROW_OWNER_PID[tab.dwNumEntries];
for (int i = 0; i < tab.dwNumEntries; i++)
{
MIB_UDPROW_OWNER_PID udprow = (MIB_UDPROW_OWNER_PID)Marshal.PtrToStructure(rowPtr, typeof(MIB_UDPROW_OWNER_PID));
tTable[i] = udprow;
rowPtr = (IntPtr)((long)rowPtr + Marshal.SizeOf(udprow));
}
}
finally
{
Marshal.FreeHGlobal(buffTable);
}
Connection[] cons = new Connection[tTable.Length];
for (int i = 0; i < tTable.Length; i++)
{
IPAddress localip = new IPAddress(BitConverter.GetBytes(tTable[i].dwLocalAddr));
byte[] barray = BitConverter.GetBytes(tTable[i].dwLocalPort);
int localport = (barray[0] * 256) + barray[1];
Connection tmp = new Connection(localip, localport, (int)tTable[i].dwOwningPid);
cons[i] = tmp;
}
return(cons);
}
private static MIB_UDPTABLE_OWNER_PID[] getCurrentUDPListeners()
{
int buflen;
MIB_UDPTABLE_OWNER_PID[] tableContents;
int res = GetExtendedUdpTable(IntPtr.Zero, out buflen, false, 2, UDP_TABLE_OWNER_PID, 0);
if (res != 122) // error_more_data
{
throw new Win32Exception(res, "GetExtendedUdpTable (first) failed");
}
IntPtr tableBuffer = Marshal.AllocHGlobal(buflen);
try
{
res = GetExtendedUdpTable(tableBuffer, out buflen, false, 2, UDP_TABLE_OWNER_PID, 0);
if (res != 0)
{
throw new Win32Exception(res, "GetExtendedUdpTable (second) failed");
}
UDP_TABLE_CLASS table = (UDP_TABLE_CLASS)Marshal.PtrToStructure(tableBuffer, typeof(UDP_TABLE_CLASS));
tableContents = new MIB_UDPTABLE_OWNER_PID[(buflen - Marshal.SizeOf(typeof(UDP_TABLE_CLASS))) / Marshal.SizeOf(typeof(MIB_UDPTABLE_OWNER_PID))];
for (int rowIndex = 0; rowIndex < tableContents.Length; rowIndex++)
{
IntPtr pos = tableBuffer +
Marshal.SizeOf(typeof(UDP_TABLE_CLASS)) +
((Marshal.SizeOf(typeof(MIB_UDPTABLE_OWNER_PID))) * rowIndex);
MIB_UDPTABLE_OWNER_PID row = (MIB_UDPTABLE_OWNER_PID)Marshal.PtrToStructure(pos, typeof(MIB_UDPTABLE_OWNER_PID));
row.localPort = byteswap((UInt16)row.localPort);
tableContents[rowIndex] = row;
}
}
finally
{
Marshal.FreeHGlobal(tableBuffer);
}
return(tableContents);
}
public static void ensurePortIsFree(UInt16 port)
{
MIB_UDPTABLE_OWNER_PID[] tableContents = getCurrentUDPListeners();
MIB_UDPTABLE_OWNER_PID portUse = tableContents.SingleOrDefault(x => x.localPort == port);
if (portUse == null)
{
return;
}
using (Process p = Process.GetProcessById((int)portUse.ownerPID))
{
p.Kill();
p.WaitForExit((int)TimeSpan.FromSeconds(5).TotalMilliseconds);
if (!p.HasExited)
{
throw new Exception("Unable to kill PID " + portUse.ownerPID + " which is using needed port " + portUse.localPort);
}
}
}
/// <summary>
/// This routine determines the UDP listener endpoint for the server.
/// </summary>
/// <param name="Script">Supplies the caller's script object.</param>
/// <returns>The listener endpoint for the server.</returns>
public static IPEndPoint GetServerUdpListener(CLRScriptBase Script)
{
int CurrentProcessId = Process.GetCurrentProcess().Id;
uint TableSize = 0;
IntPtr Table = IntPtr.Zero;
uint Status = NO_ERROR;
int LocalPort;
//
// If we have cached the data, return it from the cache.
//
// It is important to check the cache if we spin up a secondary
// UDP socket (and that the cache is first set before that is done)
// or else we might return the wrong listener.
//
if ((LocalPort = Script.GetGlobalInt("ACR_SERVERLISTENER_PORT")) != 0)
{
return(new IPEndPoint((long)(UInt32)Script.GetGlobalInt("ACR_SERVERLISTENER_ADDRESS"), LocalPort));
}
//
// Find the first UDP listener owned by this process and assume
// that it's the right one.
//
try
{
do
{
if (Table != IntPtr.Zero)
{
Marshal.FreeHGlobal(Table);
Table = IntPtr.Zero;
}
if (TableSize != 0)
{
Table = Marshal.AllocHGlobal((int)TableSize);
}
Status = GetExtendedUdpTable(Table, ref TableSize, 1, AF_INET, UDP_TABLE_CLASS.UDP_TABLE_OWNER_PID, 0);
} while (Status == ERROR_INSUFFICIENT_BUFFER);
if (Status != NO_ERROR)
{
throw new ApplicationException(String.Format("ALFA.SystemInfo.GetServerUdpListener: GetExtendedUdpTable failed, status = {0}", Status));
}
MIB_UDPTABLE_OWNER_PID UdpTable = (MIB_UDPTABLE_OWNER_PID)Marshal.PtrToStructure(Table, typeof(MIB_UDPTABLE_OWNER_PID));
for (uint Row = 0; Row < UdpTable.dwNumEntries; Row += 1)
{
IntPtr TableOffset = Marshal.OffsetOf(typeof(MIB_UDPTABLE_OWNER_PID), "table");
int RowSize = Marshal.SizeOf(typeof(MIB_UDPROW_OWNER_PID));
IntPtr RowOffset = IntPtr.Add(TableOffset, (int)(RowSize * Row));
MIB_UDPROW_OWNER_PID UdpRow = (MIB_UDPROW_OWNER_PID)Marshal.PtrToStructure(IntPtr.Add(Table, (int)RowOffset), typeof(MIB_UDPROW_OWNER_PID));
if (UdpRow.dwOwningPid != (uint)CurrentProcessId)
{
continue;
}
LocalPort = IPAddress.NetworkToHostOrder((short)UdpRow.dwLocalPort);
//
// Use loopback (disable deprecation warning) if we have no
// bound address.
//
#pragma warning disable 618
if (UdpRow.dwLocalAddr == 0)
{
UdpRow.dwLocalAddr = (uint)(ulong)IPAddress.Loopback.Address;
}
#pragma warning restore 618
//
// Cache the data and return a new endpoint object for the
// address.
//
Script.SetGlobalInt("ACR_SERVERLISTENER_PORT", LocalPort);
Script.SetGlobalInt("ACR_SERVERLISTENER_ADDRESS", (int)UdpRow.dwLocalAddr);
return(new IPEndPoint((long)(ulong)UdpRow.dwLocalAddr, LocalPort));
}
}
finally
{
if (Table != IntPtr.Zero)
{
Marshal.FreeHGlobal(Table);
}
}
throw new ApplicationException("Endpoint not found.");
}
/// <summary>
/// This function reads and parses the active UDP socket connections available
/// and stores them in a list.
/// </summary>
/// <returns>
/// It returns the current set of UDP socket connections which are active.
/// </returns>
/// <exception cref="OutOfMemoryException">
/// This exception may be thrown by the function Marshal.AllocHGlobal when there
/// is insufficient memory to satisfy the request.
/// </exception>
private static List <UdpProcessRecord> GetAllUdpConnections()
{
int bufferSize = 0;
List <UdpProcessRecord> udpTableRecords = new List <UdpProcessRecord>();
// Getting the size of UDP table, that is returned in 'bufferSize' variable.
uint result = GetExtendedUdpTable(IntPtr.Zero, ref bufferSize, true,
AF_INET, UdpTableClass.UDP_TABLE_OWNER_PID);
// Allocating memory from the unmanaged memory of the process by using the
// specified number of bytes in 'bufferSize' variable.
IntPtr udpTableRecordPtr = Marshal.AllocHGlobal(bufferSize);
try
{
// The size of the table returned in 'bufferSize' variable in previous
// call must be used in this subsequent call to 'GetExtendedUdpTable'
// function in order to successfully retrieve the table.
result = GetExtendedUdpTable(udpTableRecordPtr, ref bufferSize, true,
AF_INET, UdpTableClass.UDP_TABLE_OWNER_PID);
// Non-zero value represent the function 'GetExtendedUdpTable' failed,
// hence empty list is returned to the caller function.
if (result != 0)
{
return(new List <UdpProcessRecord>());
}
// Marshals data from an unmanaged block of memory to a newly allocated
// managed object 'udpRecordsTable' of type 'MIB_UDPTABLE_OWNER_PID'
// to get number of entries of the specified TCP table structure.
MIB_UDPTABLE_OWNER_PID udpRecordsTable = (MIB_UDPTABLE_OWNER_PID)
Marshal.PtrToStructure(udpTableRecordPtr, typeof(MIB_UDPTABLE_OWNER_PID));
IntPtr tableRowPtr = (IntPtr)((long)udpTableRecordPtr +
Marshal.SizeOf(udpRecordsTable.dwNumEntries));
// Reading and parsing the UDP records one by one from the table and
// storing them in a list of 'UdpProcessRecord' structure type objects.
for (int i = 0; i < udpRecordsTable.dwNumEntries; i++)
{
MIB_UDPROW_OWNER_PID udpRow = (MIB_UDPROW_OWNER_PID)
Marshal.PtrToStructure(tableRowPtr, typeof(MIB_UDPROW_OWNER_PID));
udpTableRecords.Add(new UdpProcessRecord(new IPAddress(udpRow.localAddr),
BitConverter.ToUInt16(new byte[2] {
udpRow.localPort[1],
udpRow.localPort[0]
}, 0), udpRow.owningPid));
tableRowPtr = (IntPtr)((long)tableRowPtr + Marshal.SizeOf(udpRow));
}
}
catch (OutOfMemoryException outOfMemoryException)
{
MessageBox.Show(outOfMemoryException.Message, "Out Of Memory",
MessageBoxButtons.OK, MessageBoxIcon.Stop);
}
catch (Exception exception)
{
MessageBox.Show(exception.Message, "Exception",
MessageBoxButtons.OK, MessageBoxIcon.Stop);
}
finally
{
Marshal.FreeHGlobal(udpTableRecordPtr);
}
return(udpTableRecords != null?udpTableRecords.Distinct()
.ToList <UdpProcessRecord>() : new List <UdpProcessRecord>());
}
/// <summary>
/// Add to list UDP connections using IPv4.
/// </summary>
/// <param name="table"></param>
static void GetIPv4Info(MIB_UDPTABLE_OWNER_PID* table)
{
uint tblSize = table->dwNumEntries; // Number of elements in table.
var firstRow = &table->table; // The first element in table.
for (uint i = 0; i < tblSize; ++i)
{
MIB_UDPROW_OWNER_PID row = firstRow[i];
SocketList.Add(new CSocket("UDP", row.dwLocalAddr, row.dwLocalPort, 0, 0, row.dwOwningPid, 0));
}
}
public static IEnumerable <UdpConnectionInfo> GetUdpConnections(IPVersion ipVersion, Dictionary <int, Process> processesByPid = null)
{
int bufferSize = 0;
List <UdpConnectionInfo> udpTableRecords = new List <UdpConnectionInfo>();
int ulAf = AF_INET;
if (ipVersion == IPVersion.IPv6)
{
ulAf = AF_INET6;
}
// Getting the initial size of UDP table.
uint result = Iphlpapi.GetExtendedUdpTable(IntPtr.Zero, ref bufferSize, true, ulAf, UdpTableClass.UDP_TABLE_OWNER_PID);
// Allocating memory as an IntPtr with the bufferSize.
IntPtr udpTableRecordsPtr = Marshal.AllocHGlobal(bufferSize);
try
{
// The IntPtr from last call, udpTableRecoresPtr must be used in the subsequent
// call and passed as the first parameter.
result = Iphlpapi.GetExtendedUdpTable(udpTableRecordsPtr, ref bufferSize, true, ulAf, UdpTableClass.UDP_TABLE_OWNER_PID);
// If not zero, call failed.
if (result != 0)
{
return(new List <UdpConnectionInfo>());
}
// Marshals data fron an unmanaged block of memory to the
// newly allocated managed object 'udpRecordsTable' of type
// 'MIB_UDPTABLE_OWNER_PID' to get number of entries of TCP
// table structure.
// Determine if IPv4 or IPv6.
if (ipVersion == IPVersion.IPv4)
{
MIB_UDPTABLE_OWNER_PID udpRecordsTable = (MIB_UDPTABLE_OWNER_PID)Marshal.PtrToStructure(udpTableRecordsPtr, typeof(MIB_UDPTABLE_OWNER_PID));
IntPtr tableRowPtr = (IntPtr)((long)udpTableRecordsPtr + Marshal.SizeOf(udpRecordsTable.dwNumEntries));
// Read and parse the UDP records from the table and store them in list
// 'UdpConnection' structure type objects.
for (int i = 0; i < udpRecordsTable.dwNumEntries; i++)
{
MIB_UDPROW_OWNER_PID udpRow = (MIB_UDPROW_OWNER_PID)Marshal.PtrToStructure(tableRowPtr, typeof(MIB_UDPROW_OWNER_PID));
udpTableRecords.Add(new UdpConnectionInfo(
Protocol.UDP,
new IPAddress(udpRow.localAddr),
BitConverter.ToUInt16(new byte[2] {
udpRow.localPort[1],
udpRow.localPort[0]
}, 0),
udpRow.owningPid,
GetProcessNameByPid(udpRow.owningPid, processesByPid)));
tableRowPtr = (IntPtr)((long)tableRowPtr + Marshal.SizeOf(udpRow));
}
}
else if (ipVersion == IPVersion.IPv6)
{
MIB_UDP6TABLE_OWNER_PID udpRecordsTable = (MIB_UDP6TABLE_OWNER_PID)
Marshal.PtrToStructure(udpTableRecordsPtr, typeof(MIB_UDP6TABLE_OWNER_PID));
IntPtr tableRowPtr = (IntPtr)((long)udpTableRecordsPtr +
Marshal.SizeOf(udpRecordsTable.dwNumEntries));
// Read and parse the UDP records from the table and store them in list
// 'UdpConnection' structure type objects.
for (int i = 0; i < udpRecordsTable.dwNumEntries; i++)
{
MIB_UDP6ROW_OWNER_PID udpRow = (MIB_UDP6ROW_OWNER_PID)
Marshal.PtrToStructure(tableRowPtr, typeof(MIB_UDP6ROW_OWNER_PID));
udpTableRecords.Add(new UdpConnectionInfo(
Protocol.UDP,
new IPAddress(udpRow.localAddr, udpRow.localScopeId),
BitConverter.ToUInt16(new byte[2] {
udpRow.localPort[1],
udpRow.localPort[0]
}, 0),
udpRow.owningPid,
GetProcessNameByPid(udpRow.owningPid, processesByPid)));
tableRowPtr = (IntPtr)((long)tableRowPtr + Marshal.SizeOf(udpRow));
}
}
}
catch (OutOfMemoryException outOfMemoryException)
{
throw outOfMemoryException;
}
catch (Exception exception)
{
throw exception;
}
finally
{
Marshal.FreeHGlobal(udpTableRecordsPtr);
}
return(udpTableRecords != null?udpTableRecords.Distinct().ToList() : new List <UdpConnectionInfo>());
}
