!!!!!!关于寻找网卡物理地址的问题!!!!!!!!!

#1

[转载]
在iphlpapi.dll里面有一个函数：GetAdaptersInfo()
好像是干这个用的。说明如下：
GetAdaptersInfo
The GetAdaptersInfo function retrieves adapter information for the local computer.

DWORD GetAdaptersInfo(
  PIP_ADAPTER_INFO pAdapterInfo,    // buffer to receive data
  PULONG pOutBufLen                 // size of data returned
);
Parameters
pAdapterInfo
[out] Pointer to a buffer that, , receives a linked list of IP_ADAPTER_INFO structures.
pOutBufLen
[in] Pointer to a ULONG variable that specifies the size of the buffer pointed to by the pAdapterInfo parameter. If this size is insufficient to hold the adapter information, GetAdaptersInfo fills in this variable with the required size, and returns an error code of ERROR_BUFFER_OVERFLOW.
Return Values
If the function succeeds, the return value is ERROR_SUCCESS.

If the function fails, the return value is one of the following error codes.

Value Meaning
ERROR_BUFFER_OVERFLOW The buffer size indicated by the pOutBufLen parameter is too small to hold the adapter information. The pOutBufLen parameter points to the required size.
ERROR_INVALID_PARAMETER The pOutBufLen parameter is NULL, or the calling process does not have read/write access to the memory pointed to by pOutBufLen, or the calling process does not have write access to the memory pointed to by the pAdapterInfo parameter.
ERROR_NO_DATA No adapter information exists for the local computer.
ERROR_NOT_SUPPORTED GetAdaptersInfo is not supported by the operating system running on the local computer.
Other If the function fails, use FormatMessage to obtain the message string for the returned error.

Requirements
  Windows NT/2000: Requires Windows 2000.
  Windows 95/98: Requires Windows 98.
  Header: Declared in Iphlpapi.h.//没有
  Library: Use Iphlpapi.lib.//没有

IP_ADAPTER_INFO
The IP_ADAPTER_INFO structure contains information about a particular network adapter on the local computer.

typedef struct _IP_ADAPTER_INFO {
  struct _IP_ADAPTER_INFO* Next;
  DWORD ComboIndex;
  char AdapterName[MAX_ADAPTER_NAME_LENGTH + 4];
  char Description[MAX_ADAPTER_DESCRIPTION_LENGTH + 4];
  UINT AddressLength;
  BYTE Address[MAX_ADAPTER_ADDRESS_LENGTH];
  DWORD Index;
  UINT Type;
  UINT DhcpEnabled;
  PIP_ADDR_STRING CurrentIpAddress;
  IP_ADDR_STRING IpAddressList;
  IP_ADDR_STRING GatewayList;
  IP_ADDR_STRING DhcpServer;
  BOOL HaveWins;
  IP_ADDR_STRING PrimaryWinsServer;
  IP_ADDR_STRING SecondaryWinsServer;
  time_t LeaseObtained;
  time_t LeaseExpires;
} IP_ADAPTER_INFO, *PIP_ADAPTER_INFO;
Members
Next
Pointer to the next adapter in the linked list of adapters.
ComboIndex
This member is unused.
AdapterName[MAX_ADAPTER_NAME_LENGTH + 4]
Specifies the name of the adapter.
Description[MAX_ADAPTER_DESCRIPTION_LENGTH + 4]
Specifies a description for the adapter.
AddressLength
Specifies the length of the hardware address for the adapter.
Address[MAX_ADAPTER_ADDRESS_LENGTH]
Specifies the hardware address for the adapter. //这个是不是你想要的？
Index
Specifies the adapter index.
Type
Specifies the adapter type.
DhcpEnabled
Specifies whether dynamic host configuration protocol (DHCP) is enabled for this adapter.
CurrentIpAddress
Specifies the current IP address for this adapter.
IpAddressList
Specifies the list of IP addresses associated with this adapter.
GatewayList
Specifies the IP address of the default gateway for this adapter.
DhcpServer
Specifies the IP address of the DHCP server for this adapter.
HaveWins
Specifies whether this adapter uses Windows Internet Name Service (WINS).
PrimaryWinsServer
Specifies the IP address of the primary WINS server.
SecondaryWinsServer
Specifies the IP address of the secondary WINS server.
LeaseObtained
Specifies the time when the current DHCP lease was obtained.
LeaseExpires
Specifies the time when the current DHCP lease will expire.
Requirements
  Windows NT/2000: Requires Windows 2000.
  Windows 95/98: Requires Windows 98.
  Header: Declared in Iptypes.h.

#2

[转载]

implementation
uses SysUtils, Windows, NB30;

function GetNetBIOSAddress : string;
var  ncb  : TNCB;
  status  : TAdapterStatus;
  lanenum : TLanaEnum;

  procedure ResetAdapter (num : char);
  begin
    fillchar(ncb,sizeof(ncb),0);
    ncb.ncb_command:=char(NCBRESET);
    ncb.ncb_lana_num:=num;
    Netbios(@ncb);
  end;

var
  lanNum  : char;
  address : record
             part1 : Longint;
             part2 : Word;//Smallint;
            end absolute status;
begin
  Result:='';

  fillchar(ncb,sizeof(ncb),0);
    ncb.ncb_command:=char(NCBENUM);
    ncb.ncb_buffer:=@lanenum;
    ncb.ncb_length:=sizeof(lanenum);
  Netbios(@ncb);

  if lanenum.length=#0 then exit;
  lanNum:=lanenum.lana[0];

  ResetAdapter(lanNum);

  fillchar(ncb,sizeof(ncb),0);
    ncb.ncb_command:=char(NCBASTAT);
    ncb.ncb_lana_num:=lanNum;
    ncb.ncb_callname[0]:='*';
    ncb.ncb_buffer:=@status;
    ncb.ncb_length:=sizeof(status);
  Netbios(@ncb);
  ResetAdapter(lanNum);

  Result:=Format('%x%x',[address.part1,address.part2]);
end;

#3

unit Main;

interface

uses
  SysUtils, WinTypes, WinProcs, Messages, Classes, Graphics, Controls,


  Forms, Dialogs, StdCtrls,
  Nb, ExtCtrls;

type
  TForm1 = class(TForm)
    Panel1: TPanel;
    Memo1: TMemo;
    Panel2: TPanel;
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.DFM}

{---------------------------------------------}
{ enumerate the lana's  - works only on WIN32 }
{---------------------------------------------}
function NbLanaEnum: TLana_Enum;
var
  NCB: TNCB;
  L_Enum: TLana_Enum;
  RetCode: Word;
begin
{$IFDEF WIN32}
  FillChar(NCB, SizeOf(NCB), 0);
  FillChar(L_Enum, SizeOf(TLana_Enum), 0);
  NCB.Command := NCB_ENUM;
  NCB.Buf := @L_Enum;
  NCB.Length := Sizeof(L_Enum);
  RetCode := NetBiosCmd(NCB);
  if RetCode <> NRC_GOODRET then begin
    L_Enum.Length := 0;
    L_Enum.Lana[0] := Byte(RetCode);
  end;
{$ELSE}                     { not supported for WIN16, fake LANA 0 }

  L_Enum.Length := 1;
  L_Enum.Lana[0] := 0;
{$ENDIF}
  Result := L_Enum;
end;

{----------------------------------------}
{ Reset the lana - don't for WIN16 !     }
{----------------------------------------}
function NbReset(l: Byte): Word;
var
  NCB: TNCB;
begin
{$IFNDEF WIN32}             { will reset all your connections for WIN1

6 }
  Result := NRC_GOODRET;    { so just fake a reset for Win16

  }
{$ELSE}
  FillChar(NCB, SizeOf(NCB), 0);
  NCB.Command := NCB_RESET;
  NCB.Lana_Num := l;
  Result := NetBiosCmd(NCB);
{$ENDIF}
end;
{----------------------------------------}
{ return the MAC address of an interface }
{ in the form of a string like :         }
{ 'xx:xx:xx:xx:xx:xx'                    }
{ using the definitions in nb.pas        }
{----------------------------------------}

function NbGetMacAddr(LanaNum: Integer): String;
var
  NCB: TNCB;
  AdpStat: TAdpStat;
  RetCode: Word;
begin
  FillChar(NCB, SizeOf(NCB), 0);
  FillChar(AdpStat, SizeOf(AdpStat), 0);
  NCB.Command := NCB_ADPSTAT;
  NCB.Buf := @AdpStat;
  NCB.Length := Sizeof(AdpStat);
  FillChar(NCB.CallName, Sizeof(TNBName), $20);
  NCB.CallName[0] := Byte('*');
  NCB.Lana_Num := LanaNum;
  RetCode := NetBiosCmd(NCB);
  if RetCode = NRC_GOODRET then begin
    Result := Format('%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x',
                   [AdpStat.ID[0],
                   AdpStat.ID[1],
                   AdpStat.ID[2],
                   AdpStat.ID[3],
                   AdpStat.ID[4],
                   AdpStat.ID[5]
                   ]);
  end else begin
    Result := '??:??:??:??:??:??';
  end;
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  Close;
end;

procedure TForm1.FormCreate(Sender: TObject);
var
  L_Enum : TLana_Enum;
  RetCode: Word;
  i: Integer;
begin
  L_Enum := NbLanaEnum;                       { enumerate lanas for WI

N NT }
  if L_Enum.Length = 0 then begin
    Button1.Caption := Format('LanaEnum err=%2.2x', [L_Enum.Lana[0]]);


    exit;
  end;

  for i := 0 to (L_Enum.Length - 1)do begin   { for every lana found

     }

    RetCode := NbReset(L_Enum.Lana[i]);       { Reset lana for WIN NT

     }
    if RetCode <> NRC_GOODRET then begin
       Button1.Caption := Format('Reset Lana %d err=%2.2x',[i, RetCode

]);
       exit;
    end;
                                             { Get MAC Address

     }
    Memo1.Lines.Add(Format('Lana %x = %s', [L_Enum.Lana[i], NbGetMacAd

dr(i)]));

  end;

  Button1.Caption := 'Stop';
end;

end.
---------------------------------- -

#4

unit Nb;

{$F+}

{  nb.pas

   16/32 bit windows netbios access (follows IBM's Netbios 3.0 spec)

   (C) CEVI VZW - 29 april 1998     -- DH (Danny.Heijl@cevi.be) --

   You can (ab)use this code as you like, but please do not remove the

credits.

   I used reference material from IBM, Microsoft, Syntax and Byte when

I wrote
   the 16-bit (DOS) c-version ages ago (in Borland Turbo C 2.0 on a 38

6SX PC)
   with a Syntax SMB server running on Interactive Unix.
   I now converted this to 16 and 32 bit Delphi code.

}

interface

uses SysUtils, Winprocs, Wintypes;

const

{ size of a netbios name }
  NBNAMESIZE    = 16;

{ max number of network adapters }
{ remeber it's BIG Blue, right ? }
  MAXLANAS      = 254;

{ NCB Command codes }

  NCB_ASYNC     = $80;   { asynch command bit to be or-ed into command

}

  NCB_CALL      = $10;   { open a session }
  NCB_LISTEN    = $11;   { wait for a call }
  NCB_HANGUP    = $12;   { end session }
  NCB_SEND      = $14;   { send data }
  NCB_RECV      = $15;   { receive data }
  NCB_RECVANY   = $16;   { receive data on any session }
  NCB_CHAINSEND = $17;   { chain send data }
  NCB_DGSEND    = $20;   { send a datagram }
  NCB_DGRECV    = $21;   { receive datagram }
  NCB_DGSENDBC  = $22;   { send broadcast datagram }
  NCB_DGREVCBC  = $23;   { receive broadcast datagram }
  NCB_ADDNAME   = $30;   { add unique name to local table }
  NCB_DELNAME   = $31;   { delete name from local table }
  NCB_RESET     = $32;   { reset adapter }
  NCB_ADPSTAT   = $33;   { adapter status }
  NCB_SSTAT     = $34;   { session status }
  NCB_CANCEL    = $35;   { cancel NCB request }
  NCB_ADDGRPNAME= $36;   { add group name to local table }
  NCB_ENUM      = $37;   { enum adapters }
  NCB_UNLINK    = $70;   { unlink remote boot code }
  NCB_SENDNA    = $71;   { send, don't wait for ACK }
  NCB_CHAINSENDNA=$72;   { chain send, but don't wait for ACK }
  NCB_LANSTALERT= $73;   { lan status alert }
  NCB_ACTION    = $77;   { enable extensions }
  NCB_FINDNAME  = $78;   { search for name on the network }
  NCB_TRACE     = $79;   { activate / stop tracing }

{ NCB return codes }

  NRC_GOODRET     = $00;    { good return
                              also returned when ASYNCH request accept

ed }
  NRC_BUFLEN      = $01;    { illegal buffer length

   }
  NRC_ILLCMD      = $03;    { illegal command

   }
  NRC_CMDTMO      = $05;    { command timed out

   }
  NRC_INCOMP      = $06;    { message incomplete, issue another comman

d  }
  NRC_BADDR       = $07;    { illegal buffer address

   }
  NRC_SNUMOUT     = $08;    { session number out of range

   }
  NRC_NORES       = $09;    { no resource available

   }
  NRC_SCLOSED     = $0a;    { session closed

   }
  NRC_CMDCAN      = $0b;    { command cancelled

   }
  NRC_DUPNAME     = $0d;    { duplicate name

   }
  NRC_NAMTFUL     = $0e;    { name table full

   }
  NRC_ACTSES      = $0f;    { no deletions, name has active sessions

   }
  NRC_LOCTFUL     = $11;    { local session table full

   }
  NRC_REMTFUL     = $12;    { remote session table full

   }
  NRC_ILLNN       = $13;    { illegal name number

   }
  NRC_NOCALL      = $14;    { no callname

   }
  NRC_NOWILD      = $15;    { cannot put * in NCB_NAME

   }
  NRC_INUSE       = $16;    { name in use on remote adapter

   }
  NRC_NAMERR      = $17;    { name deleted

   }
  NRC_SABORT      = $18;    { session ended abnormally

   }
  NRC_NAMCONF     = $19;    { name conflict detected

   }
  NRC_IFBUSY      = $21;    { interface busy, IRET before retrying

   }
  NRC_TOOMANY     = $22;    { too many commands outstanding, retry lat

er }
  NRC_BRIDGE      = $23;    { ncb_lana_num field invalid

   }
  NRC_CANOCCR     = $24;    { command completed while cancel occurring

   }
  NRC_CANCEL      = $26;    { command not valid to cancel

   }
  NRC_DUPENV      = $30;    { name defined by anther local process

   }
  NRC_ENVNOTDEF   = $34;    { environment undefined. RESET required

   }
  NRC_OSRESNOTAV  = $35;    { required OS resources exhausted

   }
  NRC_MAXAPPS     = $36;    { max number of applications exceeded

   }
  NRC_NOSAPS      = $37;    { no saps available for netbios

   }
  NRC_NORESOURCES = $38;    { requested resources are not available

   }
  NRC_INVADDRESS  = $39;    { invalid ncb address or length > segment

   }
  NRC_INVDDID     = $3B;    { invalid NCB DDID

   }
  NRC_LOCKFAIL    = $3C;    { lock of user area failed

   }
  NRC_OPENERR     = $3f;    { NETBIOS not loaded

   }
  NRC_SYSTEM      = $40;    { system error

   }

  NRC_PENDING     = $ff;    { asynchronous command is not yet finished

   }

{  Values for transport_id }

ALL_TRANSPORTS = 'M'#$00#$00#$00;
MS_NBF         = 'MNBF';

{  values for name_flags bits. }

NAME_FLAGS_MASK = $87;

GROUP_NAME      = $80;
UNIQUE_NAME     = $00;

REGISTERING     = $00;
REGISTERED      = $04;
DEREGISTERED    = $05;
DUPLICATE       = $06;
DUPLICATE_DEREG = $07;

{  Values for state }

  LISTEN_OUTSTANDING      = $01;
  CALL_PENDING            = $02;
  SESSION_ESTABLISHED     = $03;
  HANGUP_PENDING          = $04;
  HANGUP_COMPLETE         = $05;
  SESSION_ABORTED         = $06;

#5

type

{ Netbios Name }
  TNBName = array[0..(NBNAMESIZE - 1)] of byte;

{ MAC address }
  TMacAddress = array[0..5] of byte;

  PNCB = ^TNCB;

{ Netbios Control Block }

{$IFDEF WIN32}
  TNCBPostProc = procedure(P: PNCB);
{$ENDIF}

  TNCB = packed record        { Netbios Control Block }
    Command:  byte;      { command code                       }
    RetCode:  byte;      { return code                        }
    LSN:      byte;      { local session number               }
    Num:      byte;      { name number                        }
    Buf:      ^byte;     { data buffer                        }
    Length:   word;      { data length                        }
    CallName: TNBName;   { name to call                       }
    Name:     TNBName;   { our own name                       }
    RTO:      byte;      { receive time-out                   }
    STO:      byte;      { send time-out                      }
  {$IFNDEF WIN32}
    Post_Offs:word;      { asynch notification routine offset }
    Post_Seg: word;      { asynch notification routine segment}
  {$ELSE}
    PostPrc:  TNCBPostProc;{ asynch notification routine (nb30) }
  {$ENDIF}
    Lana_Num: byte;     { adapter number                     }
    Cmd_Cplt: byte;     { command completion flag            }
  {$IFDEF WIN32}
    Reserved: array[0..9] of byte;  { Reserverd for Bios use }
    Event:    THandle;  { WIN32 event handle to be signalled }
                        { for asynch cmd completion          }
  {$ELSE}
    Reserved: array[0..13] of byte;  { Reserved }
  {$ENDIF}
  end;

{ Netbios Name Info record }
  PNameInfo = ^TNameInfo;
  TNameInfo = packed record  { name info record }
    Name:   TNBName;       { netbios name }
    NameNum:byte;          { name number  }
    NameSt: byte;          { name status  }
  end;

{ Netbios adapter status }
  PAdpStat = ^TAdpStat;
  TAdpStat = packed record    { adapter status record}
    ID:       TMacAddress;   { adapter mac address           }
    VMajor:   byte;          { software version major number }
    Resvd0:   byte;
    AdpType:  byte;          { adapter type                  }
    VMinor:   byte;          { software version minor number }
    RptTime:  word;          { reporting time period         }
    RcvCRC:   word;          { receive crc errors            }
    RcvOth:   word;          { receive other errors          }
    TxmCol:   word;          { transmit collisions           }
    TxmOth:   word;          { transmit other errors         }
    TxmOK:    LongInt;       { successfull transmissions     }
    RcvOK:    LongInt;       { successfull receives          }
    TxmRetr:  word;          { transmit retries              }
    NoRcvBuf: word;          { number of 'no receive buffer' }
    T1_tmo:   word;          { t1 time-outs                  }
    Ti_tmo:   word;          { ti time_outs                  }
    Resvd1:   LongInt;
    Free_Ncbs:word;          { number of free ncb's          }
    Cfg_Ncbs: word;          { number of configured ncb's    }
    max_Ncbs: word;          { max ncb's used                }
    NoTxmBuf: word;          { number of 'no transmit buffer'}
    MaxDGSize:word;          { max. datagram size            }
    Pend_Ses: word;          { number of pending sessions    }
    Cfg_Ses:  word;          { number of configured sessions }
    Max_Ses:  word;          { max sessions used             }
    Max_SPSz: word;          { max. session packet size      }
    nNames:   word;          { number of names in local table}
    Names:    array[0..15] of TnameInfo; { local name table  }
  end;

{
   Structure returned to the NCB command NCBSSTAT is SESSION_HEADER fo

llowed
   by an array of SESSION_BUFFER structures. If the NCB_NAME starts wi

th an
   asterisk then an array of these structures is returned containing t

he
   status for all names.
}

{ session header }
  PSession_Header = ^TSession_Header;
  TSession_Header = packed record
    sess_name:            byte;
    num_sess:             byte;
    rcv_dg_outstanding:   byte;
    rcv_any_outstanding:  byte;
  end;

{ session buffer }
  PSession_Buffer = ^TSession_Buffer;
  TSession_Buffer = packed record
    lsn:                  byte;
    state:                byte;
    local_name:           TNBName;
    remote_name:          TNBName;
    rcvs_outstanding:     byte;
    sends_outstanding:    byte;
  end;

{
   Structure returned to the NCB command NCBENUM.

   On a system containing lana's 0, 2 and 3, a structure with
   length =3, lana[0]=0, lana[1]=2 and lana[2]=3 will be returned.
}
  PLana_Enum = ^TLana_Enum;
  TLANA_ENUM = packed record
    length:   byte;         {  Number of valid entries in lana[] }
    lana:     array[0..(MAXLANAS - 1)] of byte;
  end;

{
   Structure returned to the NCB command NCBFINDNAME is FIND_NAME_HEAD

ER followed
   by an array of FIND_NAME_BUFFER structures.
}

  PFind_Name_Header = ^TFind_Name_Header;
  TFind_Name_Header = packed record
    node_count:    word;
    reserved:      byte;
    unique_group:  byte;
  end;

  PFind_Name_Buffer = ^TFind_Name_Buffer;
  TFind_Name_Buffer = packed record
    length:          byte;
    access_control:  byte;
    frame_control:   byte;
    destination_addr:TMacAddress;
    source_addr:     TMacAddress;
    routing_info:    array[0..17] of byte;
  end;

{
   Structure provided with NCBACTION. The purpose of NCBACTION is to p

rovide
   transport specific extensions to netbios.
}

  PAction_Header = ^TAction_Header;
  TAction_Header = packed record
    transport_id: LongInt;
    action_code:  Word;
    reserved:     Word;
  end;

{$IFDEF WIN32}
  function Netbios(P: PNCB): Char; stdcall;
{$ENDIF}

{ Exposed functions }

function NetbiosCmd(var NCB: TNCB): Word;

implementation

{$IFDEF WIN32}
function Netbios; external 'netapi32.dll' name 'Netbios';
{$ENDIF}

{---------------------------------}
{ execute a Windows Netbios Call  }
{---------------------------------}

function NetbiosCmd(var NCB: TNCB): Word;
begin
{$IFNDEF WIN32}
  asm
    push bp                   { save bp }
    push ss                   { save ss }
    push ds                   { save ds }
    les  bx, NCB              { get segment/offset address of NCB }
    call NetBiosCall;         { 16 bit Windows Netbios call }
    xor  ah,ah
    mov  @Result, ax          { store return code }
    pop  ds                   { restore ds }
    pop  ss                   { restore ss }
    pop  bp                   { restore bp }
  end;
{$ELSE}
  Result := Word(Netbios(PNCB(@NCB))); { 32 bit Windows Netbios call }


{$ENDIF}
end;

end.

秒客网

!!!!!!关于寻找网卡物理地址的问题!!!!!!!!!

5 个解决方案

#1

#2

#3

#4

#5

#1

#2

#3

#4

#5

相关文章