Interrogation un serveur DHCP en C #

Question

Je dois obtenir la cartographie de MAC IP stockées sur le serveur DHCP, soit lui-même ou, de préférence par le biais d'un programme en cours d'exécution sur le serveur grâce à un programme en cours d'exécution sur l'un des clients DHCP.

Je comprends utilitaire netsh peut être utilisé pour obtenir la décharge mais je ne l'ai pas eu beaucoup de succès avec cela.

Les exemples de travail ou allusion à ce sujet?

Je possède des droits d'administrateur sur le serveur DHCP

Modifier

Je ne veux pas utiliser le cache arp car cela me obligerait soit ping de diffusion (ce qui est interdit sur les fenêtres) ou ping la toute adresse IP possible de sous-réseau (qui prend beaucoup de temps).

Je suis sûr que les magasins de serveur DHCP la cartographie de MAC IP, comment puis-je utiliser cette information pour carte MAC à l'adresse IP?

Answer 1

Vous pouvez utiliser le DHCP Objets composante Windows 2000 Resource Kit pour cela. Même si le composant est difficile à trouver, est fait pour Windows 2000, sort du soutien de la vie en Juillet 2010 selon Microsoft et a très peu de documentation, il fonctionne.

1. Télécharger l'outil Kit de ressources nommé Objets DHCP de par exemple ici si vous ne pouvez pas le trouver chez Microsoft. Cela vous donnera un fichier .exe qui, à son tour installera le DHCP des objets composant.
2. Enregistrez le fichier DHCPOBJS.DLL avec regsvr32 ou créer une application COM + pour elle. Ce qui est applicable dépend de la façon dont le composant COM va être utilisé sur votre système.
3. Utilisez le Type Library Importer tlbimp.exe pour créer un wrapper managé autour DHCPOBJS.DLL maintenant qu'il est enregistré par le système.
4. Dans Visual Studio, ajoutez une référence à l'enveloppe gérée. Son défaut généré est le nom DhcpObjects.dll.

Maintenant, vous pouvez écrire du code comme celui-ci contre le composant:

using DhcpObjects;
class Program {
    static void Main(string[] args) {
        var manager = new Manager();
        var server = dhcpmgr.Servers.Connect("1.2.3.4");
        // query server here
    }
}

Le programme d'installation fournit également un fichier d'aide Windows qui contient d'autres documents sur la façon d'interroger et de manipuler un serveur DHCP. La section « Le modèle d'objet » est très utile.

Answer 2

using System;
using System.Runtime.InteropServices;
using System.Collections;
using System.Net;

namespace dhcp
{
// c# class for processed clients

public class dhcpClient
{
    public string hostname { get; set; }
    public string ip       { get; set; }
    public string mac      { get; set; }
}

// structs for use with call to unmanaged code

[StructLayout(LayoutKind.Sequential)]
public struct DHCP_CLIENT_INFO_ARRAY
{
    public uint NumElements;
    public IntPtr Clients;
}

[StructLayout(LayoutKind.Sequential)]
public struct DHCP_CLIENT_UID
{
    public uint DataLength;
    public IntPtr Data;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
public struct DHCP_CLIENT_INFO
{
    public uint ip;
    public uint subnet;

    public DHCP_CLIENT_UID mac;

    [MarshalAs(UnmanagedType.LPWStr)]
    public string ClientName;

    [MarshalAs(UnmanagedType.LPWStr)]
    public string ClientComment;
}

// main

class Program
{
    static void Main()
    {
        try
        {
            // get settings

            String server, subnet;

            Console.Write("Enter server : ");
            server = Console.ReadLine();
            Console.Write("Enter subnet : ");
            subnet = Console.ReadLine();

            // gather clients

            ArrayList clients = findDhcpClients(server, subnet);

            // output results

            Console.WriteLine();

            foreach (dhcpClient d in clients)
                Console.WriteLine(String.Format("{0,-35} {1,-15} {2,-15}", d.hostname, d.ip, d.mac));

            Console.WriteLine('\n' + clients.Count.ToString() + " lease(s) in total");
        }

        catch (Exception e)
        {
            Console.WriteLine(e.ToString());
        }

        Console.ReadLine();
    }

    static ArrayList findDhcpClients(string server, string subnet)
    {
        // set up container for processed clients

        ArrayList foundClients = new ArrayList();

        // make call to unmanaged code

        uint parsedMask     = StringIPAddressToUInt32(subnet);
        uint resumeHandle   = 0;
        uint numClientsRead = 0;
        uint totalClients   = 0;

        IntPtr info_array_ptr;

        uint response = DhcpEnumSubnetClients(
            server,
            parsedMask,
            ref resumeHandle,
            65536,
            out info_array_ptr,
            ref numClientsRead,
            ref totalClients
            );

        // set up client array casted to a DHCP_CLIENT_INFO_ARRAY
        // using the pointer from the response object above

        DHCP_CLIENT_INFO_ARRAY rawClients =
            (DHCP_CLIENT_INFO_ARRAY)Marshal.PtrToStructure(info_array_ptr, typeof(DHCP_CLIENT_INFO_ARRAY));

        // loop through the clients structure inside rawClients 
        // adding to the dchpClient collection

        IntPtr current = rawClients.Clients;

        for (int i = 0; i < (int)rawClients.NumElements; i++)
        {
            // 1. Create machine object using the struct

            DHCP_CLIENT_INFO rawMachine =
                (DHCP_CLIENT_INFO)Marshal.PtrToStructure(Marshal.ReadIntPtr(current), typeof(DHCP_CLIENT_INFO));

            // 2. create new C# dhcpClient object and add to the 
            // collection (for hassle-free use elsewhere!!)

            dhcpClient thisClient = new dhcpClient();

            thisClient.ip = UInt32IPAddressToString(rawMachine.ip);

            thisClient.hostname = rawMachine.ClientName;

            thisClient.mac = String.Format("{0:x2}{1:x2}.{2:x2}{3:x2}.{4:x2}{5:x2}",
                Marshal.ReadByte(rawMachine.mac.Data),
                Marshal.ReadByte(rawMachine.mac.Data, 1),
                Marshal.ReadByte(rawMachine.mac.Data, 2),
                Marshal.ReadByte(rawMachine.mac.Data, 3),
                Marshal.ReadByte(rawMachine.mac.Data, 4),
                Marshal.ReadByte(rawMachine.mac.Data, 5));

            foundClients.Add(thisClient);

            // 3. move pointer to next machine

            current = (IntPtr)((int)current + (int)Marshal.SizeOf(typeof(IntPtr)));
        }

        return foundClients;
    }

    public static uint StringIPAddressToUInt32(string ip)
    {
        // convert string IP to uint IP e.g. "1.2.3.4" -> 16909060

        IPAddress i = System.Net.IPAddress.Parse(ip);
        byte[] ipByteArray = i.GetAddressBytes();

        uint ipUint = (uint)ipByteArray[0] << 24;
        ipUint += (uint)ipByteArray[1] << 16;
        ipUint += (uint)ipByteArray[2] << 8;
        ipUint += (uint)ipByteArray[3];

        return ipUint;
    }

    public static string UInt32IPAddressToString(uint ip)
    {
        // convert uint IP to string IP e.g. 16909060 -> "1.2.3.4"

        IPAddress i = new IPAddress(ip);
        string[] ipArray = i.ToString().Split('.');

        return ipArray[3] + "." + ipArray[2] + "." + ipArray[1] + "." + ipArray[0];
    }

    [DllImport("dhcpsapi.dll", SetLastError = true, CharSet = CharSet.Auto)]
    public static extern uint DhcpEnumSubnetClients(
            string ServerIpAddress,
            uint SubnetAddress,
        ref uint ResumeHandle,
            uint PreferredMaximum,
        out IntPtr ClientInfo,
        ref uint ElementsRead,
        ref uint ElementsTotal
    );
}
}

Answer 3

Would en utilisant arp -a faire l'affaire ... sur ma machine la sortie que je reçois est:

Je l'adresse MAC / IP remplacées par des valeurs fausses pour afficher les résultats ...

C:\Documents and Settings\Tom>arp -a

Interface: 10.203.24.196 --- 0xf0007
  Internet Address      Physical Address      Type
  10.203.24.198         02-50-f3-10-14-06     dynamic

C:\Documents and Settings\Tom>

Par bombardement à l'aide System.Diagnostics.Process, vous pouvez rediriger la sortie vers un flux d'entrée et de lire ce ...

Hope this helps, Meilleures salutations, Tom.