/** Get the current linkg status
* @param adapter adapter handle received by a call to init_adapter
* @param linkstate the current link state
* @return 1: succeeded, 0: failed
*/
static int
get_link_state(struct packet_adapter *pa, NDIS_MEDIA_STATE *linkstate)
{
int ret = 0;
if(pa != NULL) {
PPACKET_OID_DATA ppacket_oid_data;
/* get the media connect status of the selected adapter */
ppacket_oid_data = (PPACKET_OID_DATA)malloc(sizeof(PACKET_OID_DATA) + sizeof(NDIS_MEDIA_STATE));
if (ppacket_oid_data != NULL) {
ppacket_oid_data->Oid = OID_GEN_MEDIA_CONNECT_STATUS;
ppacket_oid_data->Length = sizeof(NDIS_MEDIA_STATE);
if (PacketRequest(pa->lpAdapter, FALSE, ppacket_oid_data)) {
*linkstate = (*((PNDIS_MEDIA_STATE)(ppacket_oid_data->Data)));
ret = 1;
}
free(ppacket_oid_data);
}
}
return ret;
}
static BOOL get_connected_status (BOOL *is_up)
{
struct {
PACKET_OID_DATA oidData;
DWORD connected;
} oid;
const ADAPTER *adapter;
if (!_pkt_inf)
return (FALSE);
adapter = (const ADAPTER*) _pkt_inf->adapter;
memset (&oid, 0, sizeof(oid));
oid.oidData.Oid = OID_GEN_MEDIA_CONNECT_STATUS;
oid.oidData.Length = sizeof(oid.connected);
if (!PacketRequest(adapter, FALSE, &oid.oidData))
return (FALSE);
*is_up = (*(DWORD*) &oid.oidData.Data == NdisMediaStateConnected);
return (TRUE);
}
/*
* Return NDIS version as MSB.LSB.
*/
int pkt_get_api_ver (DWORD *ver)
{
struct {
PACKET_OID_DATA oidData;
DWORD version;
} oid;
BOOL rc;
const ADAPTER *adapter;
if (!_pkt_inf)
return (0);
adapter = (const ADAPTER*) _pkt_inf->adapter;
memset (&oid, 0, sizeof(oid));
oid.oidData.Length = sizeof(oid.version);
oid.oidData.Oid = OID_GEN_DRIVER_VERSION;
rc = PacketRequest (adapter, FALSE, &oid.oidData);
if (rc)
*ver = *(WORD*) &oid.oidData.Data; /* only 16-bit in version */
return (rc);
}
static BOOL get_interface_mtu (DWORD *mtu)
{
struct {
PACKET_OID_DATA oidData;
DWORD mtu;
} oid;
const ADAPTER *adapter;
if (!_pkt_inf)
return (FALSE);
adapter = (const ADAPTER*) _pkt_inf->adapter;
memset (&oid, 0, sizeof(oid));
oid.oidData.Oid = OID_GEN_MAXIMUM_TOTAL_SIZE;
oid.oidData.Length = sizeof(oid.mtu);
if (!PacketRequest(adapter, FALSE, &oid.oidData))
return (FALSE);
*mtu = *(DWORD*) &oid.oidData.Data;
return (TRUE);
}
static BOOL get_interface_speed (DWORD *speed)
{
struct {
PACKET_OID_DATA oidData;
DWORD speed;
} oid;
const ADAPTER *adapter;
if (!_pkt_inf)
return (FALSE);
adapter = (const ADAPTER*) _pkt_inf->adapter;
memset (&oid, 0, sizeof(oid));
oid.oidData.Oid = OID_GEN_LINK_SPEED;
oid.oidData.Length = sizeof(oid.speed);
if (!PacketRequest(adapter, FALSE, &oid.oidData))
return (FALSE);
*speed = (*(DWORD*)&oid.oidData.Data) / 10000;
return (TRUE);
}
BOOLEAN PacketSetFilter( LPADAPTER AdapterObject, ULONG Filter )
{
BOOLEAN Status;
ULONG IoCtlBufferLength = (sizeof(PACKET_OID_DATA)+sizeof(ULONG)-1);
LPPACKET lpPacket;
lpPacket = PacketAllocatePacket( AdapterObject, IoCtlBufferLength );
#define lpOidData ((PPACKET_OID_DATA)(lpPacket->Buffer))
if ( lpPacket ) {
lpOidData->Oid = OID_GEN_CURRENT_PACKET_FILTER;
lpOidData->Length = sizeof(ULONG);
*((PULONG)lpOidData->Data) = Filter;
Status = PacketRequest( AdapterObject, lpPacket, TRUE );
PacketFreePacket( lpPacket );
} else {
Status = FALSE;
}
#undef lpOidData
return Status;
}
static BOOL get_interface_type (WORD *type)
{
struct {
PACKET_OID_DATA oidData;
DWORD link;
} oid;
const ADAPTER *adapter;
if (!_pkt_inf)
return (FALSE);
adapter = (const ADAPTER*) _pkt_inf->adapter;
memset (&oid, 0, sizeof(oid));
oid.oidData.Oid = OID_GEN_MEDIA_IN_USE;
oid.oidData.Length = sizeof(oid.link);
if (!PacketRequest(adapter, FALSE, &oid.oidData))
return (FALSE);
*type = *(WORD*) &oid.oidData.Data;
return (TRUE);
}
OstProto::LinkState WinPcapPort::linkState()
{
memset(linkStateOid_, 0, sizeof(PACKET_OID_DATA) + sizeof(uint));
linkStateOid_->Oid = OID_GEN_MEDIA_CONNECT_STATUS;
linkStateOid_->Length = sizeof(uint);
if (PacketRequest(adapter_, 0, linkStateOid_))
{
uint state;
if (linkStateOid_->Length == sizeof(state))
{
memcpy((void*)&state, (void*)linkStateOid_->Data,
linkStateOid_->Length);
if (state == 0)
linkState_ = OstProto::LinkStateUp;
else if (state == 1)
linkState_ = OstProto::LinkStateDown;
}
}
return linkState_;
}
/*
* Return traffic statisistics since started (stats) and
* total since adapter was opened.
*
* \note 'stats' only count traffic we received and transmitted.
*/
int pkt_get_stats (struct PktStats *stats, struct PktStats *total)
{
const ADAPTER *adapter;
struct bpf_stat b_stat;
struct {
PACKET_OID_DATA oidData;
DWORD value;
} oid;
DWORD count[4];
if (!_pkt_inf)
return (0);
adapter = (const ADAPTER*) _pkt_inf->adapter;
if (!PacketGetStatsEx(adapter,&b_stat))
return (0);
memset (total, 0, sizeof(*total)); /* we don't know yet */
memset (&count, 0, sizeof(count));
/*
* Query: OID_GEN_RCV_OK, OID_GEN_RCV_ERROR
* OID_GEN_XMIT_OK, OID_GEN_XMIT_ERROR
*/
memset (&oid, 0, sizeof(oid));
oid.oidData.Oid = OID_GEN_RCV_OK;
oid.oidData.Length = sizeof(oid.value);
if (!PacketRequest (adapter, FALSE, &oid.oidData))
goto no_total;
count[0] = *(DWORD*) &oid.oidData.Data;
memset (&oid, 0, sizeof(oid));
oid.oidData.Oid = OID_GEN_XMIT_OK;
oid.oidData.Length = sizeof(oid.value);
if (!PacketRequest (adapter, FALSE, &oid.oidData))
goto no_total;
count[1] = *(DWORD*) &oid.oidData.Data;
memset (&oid, 0, sizeof(oid));
oid.oidData.Oid = OID_GEN_RCV_ERROR;
oid.oidData.Length = sizeof(oid.value);
if (!PacketRequest (adapter, FALSE, &oid.oidData))
goto no_total;
count[2] = *(DWORD*) &oid.oidData.Data;
memset (&oid, 0, sizeof(oid));
oid.oidData.Oid = OID_GEN_XMIT_ERROR;
oid.oidData.Length = sizeof(oid.value);
if (!PacketRequest (adapter, FALSE, &oid.oidData))
goto no_total;
count[3] = *(DWORD*) &oid.oidData.Data;
no_total:
total->in_packets = count[0];
total->out_packets = count[1];
total->in_errors = count[2];
total->out_errors = count[3];
stats->in_packets = b_stat.bs_recv;
stats->in_bytes = num_tx_bytes;
stats->out_packets = num_tx_pkt;
stats->out_bytes = num_tx_bytes;
stats->in_errors = 0UL;
stats->out_errors = num_tx_errors;
stats->lost = b_stat.bs_drop + b_stat.ps_ifdrop;
return (1);
}
/**
* Initialise WinPcap and return our MAC address.
*/
int pkt_eth_init (mac_address *mac_addr)
{
struct {
PACKET_OID_DATA oidData;
char descr[512];
} oid;
const ADAPTER *adapter = NULL;
DWORD thread_id;
BOOL is_up;
if (_watt_is_win9x) /**< \todo Support Win-9x too */
{
(*_printf) (_LANG("Win-NT or later reqired.\n"));
_pkt_errno = PDERR_GEN_FAIL;
return (WERR_ILL_DOSX);
}
if (!_watt_no_config || _watt_user_config_fn)
parse_config_pass_1();
_pkt_inf = calloc (sizeof(*_pkt_inf), 1);
if (!_pkt_inf)
{
(*_printf) (_LANG("Failed to allocate WinPcap DRIVER data.\n"));
_pkt_errno = PDERR_GEN_FAIL;
return (WERR_NO_MEM);
}
if (debug_on >= 2 && dump_fname[0])
dump_file = fopen_excl (ExpandVarStr(dump_fname), "w+t");
if (!PacketInitModule(TRUE, dump_file))
{
(*_printf) (_LANG("Failed to initialise WinPcap.\n"));
pkt_release();
_pkt_errno = PDERR_NO_DRIVER;
return (WERR_PKT_ERROR);
}
if (!_pktdrvrname[0] &&
!find_adapter(_pktdrvrname,sizeof(_pktdrvrname)))
{
(*_printf) (_LANG("No WinPcap driver found.\n"));
_pkt_errno = PDERR_NO_DRIVER;
return (WERR_NO_DRIVER);
}
TCP_CONSOLE_MSG (2, ("device %s\n", _pktdrvrname));
adapter = PacketOpenAdapter (_pktdrvrname);
if (!adapter)
{
if (debug_on > 0)
(*_printf) (_LANG("PacketOpenAdapter (\"%s\") failed; %s\n"),
_pktdrvrname, win_strerror(GetLastError()));
pkt_release();
return (WERR_NO_DRIVER);
}
_pkt_inf->adapter = adapter;
#if defined(USE_DYN_PACKET)
_pkt_inf->adapter_info = NULL;
#else
_pkt_inf->adapter_info = PacketFindAdInfo (_pktdrvrname);
#endif
/* Query the NIC driver for the adapter description
*/
memset (&oid, 0, sizeof(oid));
oid.oidData.Oid = OID_GEN_VENDOR_DESCRIPTION;
oid.oidData.Length = sizeof(oid.descr);
if (PacketRequest (adapter, FALSE, &oid.oidData))
StrLcpy (_pktdrvr_descr, (char*)oid.oidData.Data, sizeof(_pktdrvr_descr));
else
{
(*_printf) (_LANG("PacketRequest() failed; %s\n"),
win_strerror(GetLastError()));
pkt_release();
return (WERR_PKT_ERROR);
}
if (!get_interface_type(&_pktdevclass))
{
pkt_release();
return (WERR_PKT_ERROR);
}
if (get_connected_status(&is_up) && !is_up)
(*_printf) (_LANG("Warning: the adapter %s is down\n"), _pktdrvrname);
switch (_pktdevclass)
{
case PDCLASS_TOKEN:
_pkt_ip_ofs = sizeof(tok_Header);
break;
case PDCLASS_ETHER:
_pkt_ip_ofs = sizeof(eth_Header);
break;
case PDCLASS_FDDI:
_pkt_ip_ofs = sizeof(fddi_Header);
break;
case PDCLASS_ARCNET:
_pkt_ip_ofs = ARC_HDRLEN;
break;
default:
pkt_release();
(*_printf) (_LANG("WinPcap-ERROR: Unsupported driver class %dh\n"),
_pktdevclass);
_pkt_errno = PDERR_NO_CLASS;
return (WERR_PKT_ERROR);
}
if (!pkt_get_addr(mac_addr)) /* get our MAC address */
{
pkt_release();
return (WERR_PKT_ERROR);
}
pktq_init (&_pkt_inf->pkt_queue,
sizeof(_pkt_inf->rx_buf[0]), /* RX_SIZE */
DIM(_pkt_inf->rx_buf), /* RX_BUFS */
(char*)&_pkt_inf->rx_buf);
_pkt_inf->npf_buf_size = RX_SIZE * pkt_num_rx_bufs;
_pkt_inf->npf_buf = malloc (_pkt_inf->npf_buf_size);
if (!_pkt_inf->npf_buf)
{
(*_printf) (_LANG("Failed to allocate %d byte Rx buffer.\n"),
_pkt_inf->npf_buf_size);
pkt_release();
_pkt_errno = PDERR_GEN_FAIL;
return (WERR_NO_MEM);
}
PacketSetMode (adapter, PACKET_MODE_CAPT);
PacketSetBuff (adapter, _pkt_inf->npf_buf_size);
PacketSetMinToCopy (adapter, ETH_MIN);
/* PacketReceivePacket() blocks until something is received
*/
PacketSetReadTimeout ((ADAPTER*)adapter, 0);
/* Set Rx-mode forced via config.
*/
if (_pkt_forced_rxmode != -1)
{
_pkt_forced_rxmode &= 0xFFFF; /* clear bits not set via ARG_ATOX_W */
if (_pkt_forced_rxmode == 0 || /* check illegal bit-values */
(_pkt_forced_rxmode & 0x10) ||
(_pkt_forced_rxmode & 0x40) ||
(_pkt_forced_rxmode > 0x80))
{
TCP_CONSOLE_MSG (0, ("Illegal Rx-mode (0x%02X) specified\n",
_pkt_forced_rxmode));
_pkt_forced_rxmode = -1;
}
}
if (pkt_get_rcv_mode())
_pkt_rxmode0 = _pkt_rxmode;
if (_pkt_forced_rxmode != -1)
pkt_set_rcv_mode (_pkt_forced_rxmode);
else pkt_set_rcv_mode (RXMODE_DEFAULT);
#if 1
_pkt_inf->recv_thread = CreateThread (NULL, 2048, pkt_recv_thread,
NULL, 0, &thread_id);
#else
_pkt_inf->recv_thread = _beginthreadex (NULL, 2048, pkt_recv_thread,
NULL, 0, &thread_id);
#endif
if (!_pkt_inf->recv_thread)
{
(*_printf) (_LANG("Failed to create receiver thread; %s\n"),
win_strerror(GetLastError()));
pkt_release();
_pkt_errno = PDERR_GEN_FAIL;
return (WERR_PKT_ERROR);
}
if (thr_realtime)
SetThreadPriority (_pkt_inf->recv_thread,
THREAD_PRIORITY_TIME_CRITICAL);
TCP_CONSOLE_MSG (2, ("capture thread-id %lu\n", thread_id));
#if defined(USE_DEBUG)
if (debug_on >= 2)
{
(*_printf) ("link-details:\n");
show_link_details();
}
#endif
return (0);
}
int gethwaddr (void * memory, char const * device)
{
#if defined (__linux__)
# include <ifaddrs.h>
# include <netpacket/packet.h>
# include <sys/ioctl.h>
struct ifreq ifreq;
int fd;
if ((fd = socket (AF_INET, SOCK_DGRAM, 0)) == -1)
{
error (1, errno, "%s: %s", __func__, device);
}
memcpy (ifreq.ifr_name, device, sizeof (ifreq.ifr_name));
if (ioctl (fd, SIOCGIFHWADDR, &ifreq) == -1)
{
close (fd);
return (-1);
}
memcpy (memory, ifreq.ifr_ifru.ifru_hwaddr.sa_data, ETHER_ADDR_LEN);
close (fd);
#elif defined (__linux__)
#include <ifaddrs.h>
struct ifaddrs *ifaddrs;
struct ifaddrs *ifaddr;
if (getifaddrs (&ifaddrs) == -1)
{
error (1, errno, "No interfaces available");
}
for (ifaddr = ifaddrs; ifaddr; ifaddr = ifaddr->ifa_next)
{
if (strcmp (device, ifaddr->ifa_name))
{
continue;
}
if (!ifaddr->ifa_addr)
{
continue;
}
if (ifaddr->ifa_addr->sa_family == AF_PACKET)
{
struct sockaddr_ll * sockaddr = (struct sockaddr_ll *) (ifaddr->ifa_addr);
memcpy (memory, sockaddr->sll_addr, ETHER_ADDR_LEN);
break;
}
}
freeifaddrs (ifaddrs);
#elif defined (__APPLE__)
#include <ifaddrs.h>
#include <net/if_dl.h>
struct ifaddrs *ifaddrs;
struct ifaddrs *ifaddr;
if (getifaddrs (&ifaddrs) == -1)
{
error (1, errno, "No interfaces available");
}
for (ifaddr = ifaddrs; ifaddr; ifaddr = ifaddr->ifa_next)
{
if (strcmp (device, ifaddr->ifa_name))
{
continue;
}
if (!ifaddr->ifa_addr)
{
continue;
}
if (ifaddr->ifa_addr->sa_family == AF_LINK)
{
struct sockaddr_dl * sockaddr = (struct sockaddr_dl *) (ifaddr->ifa_addr);
memcpy (memory, LLADDR (sockaddr), ETHER_ADDR_LEN);
break;
}
}
freeifaddrs (ifaddrs);
#elif defined (__OpenBSD__)
#include <ifaddrs.h>
#include <net/if_dl.h>
struct ifaddrs *ifaddrs;
struct ifaddrs *ifaddr;
if (getifaddrs (&ifaddrs) == -1)
{
error (1, errno, "No interfaces available");
}
for (ifaddr = ifaddrs; ifaddr; ifaddr = ifaddr->ifa_next)
{
if (strcmp (device, ifaddr->ifa_name))
{
continue;
}
if (!ifaddr->ifa_addr)
{
continue;
}
if (ifaddr->ifa_addr->sa_family == AF_LINK)
{
struct sockaddr_dl * sockaddr = (struct sockaddr_dl *) (ifaddr->ifa_addr);
memcpy (memory, LLADDR (sockaddr), ETHER_ADDR_LEN);
break;
}
}
freeifaddrs (ifaddrs);
#elif defined (WINPCAP) || defined (LIBPCAP)
LPADAPTER adapter = PacketOpenAdapter ((PCHAR)(device));
PPACKET_OID_DATA data = (PPACKET_OID_DATA)(malloc (ETHER_ADDR_LEN + sizeof (PACKET_OID_DATA)));
if (!data)
{
error (1, errno, "Can't allocate packet: %s", device);
}
data->Oid = OID_802_3_CURRENT_ADDRESS;
data->Length = ETHER_ADDR_LEN;
if ((adapter == 0) || (adapter->hFile == INVALID_HANDLE_VALUE))
{
error (1, errno, "Can't access interface: %s", device);
}
if (!PacketRequest (adapter, FALSE, data))
{
memset (memory, 0, ETHER_ADDR_LEN);
PacketCloseAdapter (adapter);
free (data);
return (-1);
}
memcpy (memory, data->Data, data->Length);
PacketCloseAdapter (adapter);
free (data);
#else
#error "Unknown environment"
#endif
return (0);
}
/**
* Open a network adapter and set it up for packet input
*
* @param adapter_num the index of the adapter to use
* @param mac_addr the MAC address of the adapter is stored here (if != NULL)
* @param input a function to call to receive a packet
* @param arg argument to pass to input
* @param linkstate the initial link state
* @return an adapter handle on success, NULL on failure
*/
void*
init_adapter(int adapter_num, char *mac_addr, input_fn input, void *arg, enum link_adapter_event *linkstate)
{
char *AdapterList[MAX_NUM_ADAPTERS];
#ifndef PACKET_LIB_QUIET
int i;
#endif /* PACKET_LIB_QUIET */
char AdapterName[ADAPTER_NAME_LEN]; /* string that contains a list of the network adapters */
int AdapterNum;
PPACKET_OID_DATA ppacket_oid_data;
unsigned char ethaddr[ETHARP_HWADDR_LEN];
struct packet_adapter *pa;
NDIS_MEDIA_STATE mediastate;
pa = (struct packet_adapter *)malloc(sizeof(struct packet_adapter));
if (!pa) {
printf("Unable to alloc the adapter!\n");
return NULL;
}
memset(pa, 0, sizeof(struct packet_adapter));
pa->input = input;
pa->input_fn_arg = arg;
AdapterNum = get_adapter_list(AdapterList, MAX_NUM_ADAPTERS, AdapterName, ADAPTER_NAME_LEN);
/* print all adapter names */
if (AdapterNum <= 0) {
free(pa);
return NULL; /* no adapters found */
}
#ifndef PACKET_LIB_QUIET
for (i = 0; i < AdapterNum; i++) {
LPADAPTER lpAdapter;
printf("%2i: %s\n", i, AdapterList[i]);
/* set up the selected adapter */
lpAdapter = PacketOpenAdapter(AdapterList[i]);
if (lpAdapter && (lpAdapter->hFile != INVALID_HANDLE_VALUE)) {
ppacket_oid_data = (PPACKET_OID_DATA)malloc(sizeof(PACKET_OID_DATA) + PACKET_OID_DATA_SIZE);
if (ppacket_oid_data) {
ppacket_oid_data->Oid = OID_GEN_VENDOR_DESCRIPTION;
ppacket_oid_data->Length = PACKET_OID_DATA_SIZE;
if (PacketRequest(lpAdapter, FALSE, ppacket_oid_data)) {
printf(" Name: \"%s\"\n", ppacket_oid_data->Data);
}
free(ppacket_oid_data);
}
PacketCloseAdapter(lpAdapter);
lpAdapter = NULL;
}
}
#endif /* PACKET_LIB_QUIET */
/* invalid adapter index -> check this after printing the adapters */
if (adapter_num < 0) {
printf("Invalid adapter_num: %d\n", adapter_num);
free(pa);
return NULL;
}
/* adapter index out of range */
if (adapter_num >= AdapterNum) {
printf("Invalid adapter_num: %d\n", adapter_num);
free(pa);
return NULL;
}
#ifndef PACKET_LIB_QUIET
printf("Using adapter_num: %d\n", adapter_num);
#endif /* PACKET_LIB_QUIET */
/* set up the selected adapter */
pa->lpAdapter = PacketOpenAdapter(AdapterList[adapter_num]);
if (!pa->lpAdapter || (pa->lpAdapter->hFile == INVALID_HANDLE_VALUE)) {
free(pa);
return NULL;
}
/* alloc the OID packet */
ppacket_oid_data = (PPACKET_OID_DATA)malloc(sizeof(PACKET_OID_DATA) + PACKET_OID_DATA_SIZE);
if (!ppacket_oid_data) {
PacketCloseAdapter(pa->lpAdapter);
free(pa);
return NULL;
}
/* get the description of the selected adapter */
ppacket_oid_data->Oid = OID_GEN_VENDOR_DESCRIPTION;
ppacket_oid_data->Length = PACKET_OID_DATA_SIZE;
if (PacketRequest(pa->lpAdapter, FALSE, ppacket_oid_data)) {
printf("Using adapter: \"%s\"", ppacket_oid_data->Data);
}
/* get the MAC address of the selected adapter */
ppacket_oid_data->Oid = OID_802_3_PERMANENT_ADDRESS;
ppacket_oid_data->Length = ETHARP_HWADDR_LEN;
if (!PacketRequest(pa->lpAdapter, FALSE, ppacket_oid_data)) {
printf("ERROR getting the adapter's HWADDR, maybe it's not an ethernet adapter?\n");
PacketCloseAdapter(pa->lpAdapter);
free(pa);
return NULL;
}
/* copy the MAC address */
memcpy(ðaddr, ppacket_oid_data->Data, ETHARP_HWADDR_LEN);
free(ppacket_oid_data);
if (mac_addr != NULL) {
/* copy the MAC address to the user supplied buffer, also */
memcpy(mac_addr, ðaddr, ETHARP_HWADDR_LEN);
}
printf(" [MAC: %02X:%02X:%02X:%02X:%02X:%02X]\n", ethaddr[0], ethaddr[1], ethaddr[2],
ethaddr[3], ethaddr[4], ethaddr[5]);
/* some more adapter settings */
PacketSetBuff(pa->lpAdapter, PACKET_ADAPTER_BUFSIZE);
PacketSetReadTimeout(pa->lpAdapter, 1);
PacketSetHwFilter(pa->lpAdapter, NDIS_PACKET_TYPE_ALL_LOCAL | NDIS_PACKET_TYPE_PROMISCUOUS);
/* set up packet descriptor (the application input buffer) */
if ((pa->lpPacket = PacketAllocatePacket()) == NULL) {
printf("ERROR setting up a packet descriptor\n");
PacketCloseAdapter(pa->lpAdapter);
free(pa);
return NULL;
}
PacketInitPacket(pa->lpPacket,(char*)pa->buffer, sizeof(pa->buffer));
if(get_link_state(pa, &mediastate)) {
*linkstate = (mediastate == NdisMediaStateConnected ? LINKEVENT_UP : LINKEVENT_DOWN);
}
return pa;
}
void PcapLiveDevice::setDeviceMacAddress()
{
#ifdef WIN32
LPADAPTER adapter = PacketOpenAdapter((char*)m_Name);
if (adapter == NULL)
{
LOG_ERROR("Error in retrieving MAC address: Adapter is NULL");
return;
}
uint8_t buffer[512];
PACKET_OID_DATA* oidData = (PACKET_OID_DATA*)buffer;
oidData->Oid = OID_802_3_CURRENT_ADDRESS;
oidData->Length = 6;
oidData->Data[0] = 0;
bool status = PacketRequest(adapter, false, oidData);
if(status)
{
if(oidData->Length == 6)
{
/* copy value from driver */
m_MacAddress = MacAddress(oidData->Data[0], oidData->Data[1], oidData->Data[2], oidData->Data[3], oidData->Data[4], oidData->Data[5]);
LOG_DEBUG(" MAC address: %s", m_MacAddress.toString().c_str());
} else
{
/* the driver returned a value that is longer than expected (and longer than the given buffer) */
LOG_DEBUG("Error in retrieving MAC address: Size of Oid larger than 6, OidLen:%lu", oidData->Length);
return;
}
}
else
{
LOG_DEBUG("Error in retrieving MAC address: PacketRequest failed");
}
#elif LINUX
struct ifreq ifr;
memset(&ifr, 0, sizeof(ifr));
strncpy(ifr.ifr_name, m_Name, sizeof(ifr.ifr_name));
int socketfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);
if (ioctl(socketfd, SIOCGIFHWADDR, &ifr) == -1)
{
LOG_DEBUG("Error in retrieving MAC address: ioctl() returned -1");
return;
}
m_MacAddress = MacAddress(ifr.ifr_hwaddr.sa_data[0], ifr.ifr_hwaddr.sa_data[1], ifr.ifr_hwaddr.sa_data[2], ifr.ifr_hwaddr.sa_data[3], ifr.ifr_hwaddr.sa_data[4], ifr.ifr_hwaddr.sa_data[5]);
#elif MAC_OS_X
int mib[6];
size_t len;
mib[0] = CTL_NET;
mib[1] = AF_ROUTE;
mib[2] = 0;
mib[3] = AF_LINK;
mib[4] = NET_RT_IFLIST;
mib[5] = if_nametoindex(m_Name);
if ((mib[5] == 0)){
LOG_ERROR("Error in retrieving MAC address: if_nametoindex error");
return;
}
if (sysctl(mib, 6, NULL, &len, NULL, 0) < 0) {
LOG_ERROR("Error in retrieving MAC address: sysctl 1 error");
return;
}
uint8_t buf[len];
if (sysctl(mib, 6, buf, &len, NULL, 0) < 0) {
LOG_ERROR("Error in retrieving MAC address: sysctl 2 error");
return;
}
struct if_msghdr*ifm = (struct if_msghdr *)buf;
struct sockaddr_dl* sdl = (struct sockaddr_dl *)(ifm + 1);
uint8_t* ptr = (uint8_t*)LLADDR(sdl);
m_MacAddress = MacAddress(ptr[0], ptr[1], ptr[2], ptr[3], ptr[4], ptr[5]);
#endif
}
int main()
{
//define a pointer to an ADAPTER structure
LPADAPTER lpAdapter = 0;
//define a pointer to a PACKET structure
LPPACKET lpPacket;
int i;
DWORD dwErrorCode;
//ascii strings
char AdapterName[8192]; // string that contains a list of the network adapters
char *temp,*temp1;
int AdapterNum=0,Open;
ULONG AdapterLength;
#if 1
unsigned char oh[1536];
PPACKET_OID_DATA OidData = oh;
BOOLEAN Status;
unsigned int *p = (unsigned int *) oh;
unsigned char *k;
int x,
symbol;
#endif
char buffer[256000]; // buffer to hold the data coming from the driver
struct bpf_stat stat;
//
// Obtain the name of the adapters installed on this machine
//
printf("Packet.dll test application. Library version:%s\n", PacketGetVersion());
printf("Adapters installed:\n");
i=0;
AdapterLength = sizeof(AdapterName);
if(PacketGetAdapterNames(AdapterName,&AdapterLength)==FALSE){
printf("Unable to retrieve the list of the adapters!\n");
return -1;
}
temp=AdapterName;
temp1=AdapterName;
while ((*temp!='\0')||(*(temp-1)!='\0'))
{
if (*temp=='\0')
{
memcpy(AdapterList[i],temp1,temp-temp1);
temp1=temp+1;
i++;
}
temp++;
}
AdapterNum=i;
for (i=0;i<AdapterNum;i++)
printf("\n%d- %s\n",i+1,AdapterList[i]);
printf("\n");
do
{
printf("Select the number of the adapter to open : ");
scanf_s("%d",&Open);
if (Open>AdapterNum) printf("\nThe number must be smaller than %d",AdapterNum);
} while (Open>AdapterNum);
lpAdapter = PacketOpenAdapter(AdapterList[Open-1]);
if (!lpAdapter || (lpAdapter->hFile == INVALID_HANDLE_VALUE))
{
dwErrorCode=GetLastError();
printf("Unable to open the adapter, Error Code : %lx\n",dwErrorCode);
return -1;
}
#if 1
OidData->Oid = OID_GEN_PHYSICAL_MEDIUM;
OidData->Length = 6;
ZeroMemory(OidData->Data, 6);
Status = PacketRequest(lpAdapter, FALSE, OidData);
printf("[%d]\n", Status);
printf("%8.8x %8.8x\n", *p, *(p + 1));
k = (unsigned char *) OidData->Data;
x = 6;
while (x--) printf("%2.2x", *k++);
putchar ('\n');
#endif
// set the network adapter in promiscuous mode
if(PacketSetHwFilter(lpAdapter,NDIS_PACKET_TYPE_PROMISCUOUS)==FALSE){
printf("Warning: unable to set promiscuous mode!\n");
}
// set a 512K buffer in the driver
if(PacketSetBuff(lpAdapter,512000)==FALSE){
printf("Unable to set the kernel buffer!\n");
return -1;
}
// set a 1 second read timeout
if(PacketSetReadTimeout(lpAdapter,1000)==FALSE){
printf("Warning: unable to set the read tiemout!\n");
}
//allocate and initialize a packet structure that will be used to
//receive the packets.
if((lpPacket = PacketAllocatePacket())==NULL){
printf("\nError: failed to allocate the LPPACKET structure.");
return (-1);
}
PacketInitPacket(lpPacket,(char*)buffer,256000);
//main capture loop
while(!_kbhit())
{
// capture the packets
if(PacketReceivePacket(lpAdapter,lpPacket,TRUE)==FALSE){
printf("Error: PacketReceivePacket failed");
return (-1);
}
PrintPackets(lpPacket);
}
//print the capture statistics
if(PacketGetStats(lpAdapter,&stat)==FALSE){
printf("Warning: unable to get stats from the kernel!\n");
}
else
printf("\n\n%d packets received.\n%d Packets lost",stat.bs_recv,stat.bs_drop);
PacketFreePacket(lpPacket);
// close the adapter and exit
PacketCloseAdapter(lpAdapter);
return (0);
}
DWORD _stdcall PacketIOControl(DWORD dwService,
DWORD dwDDB,
DWORD hDevice,
PDIOCPARAMETERS pDiocParms)
{
// called from applications
POPEN_INSTANCE Open;
NDIS_STATUS Status;
UCHAR AdapterBuffer[5];
NDIS_STRING AdapterName = NDIS_STRING_CONST(AdapterBuffer);
switch (dwService) {
case DIOC_OPEN:
return NDIS_STATUS_SUCCESS;
case DIOC_CLOSEHANDLE:
if ((Open = GetOpen(hDevice)) != NULL)
PacketUnbindAdapter(&Status, Open, NULL);
return NDIS_STATUS_SUCCESS;
case IOCTL_EPACKET_VERSION:
if (pDiocParms->cbOutBuffer < 2)
*(DWORD *)(pDiocParms->lpcbBytesReturned) = 0;
else {
((BYTE *)pDiocParms->lpvOutBuffer)[0] = MAJOR_VERSION;
((BYTE *)pDiocParms->lpvOutBuffer)[1] = MINOR_VERSION;
*(DWORD *)pDiocParms->lpcbBytesReturned = 2;
}
return NDIS_STATUS_SUCCESS;
case IOCTL_EPACKET_BIND:
memcpy(AdapterName.Buffer, (BYTE *)pDiocParms->lpvInBuffer,
min(strlen((char *)pDiocParms->lpvInBuffer), sizeof(AdapterBuffer)-1));
AdapterName.Buffer[sizeof(AdapterBuffer)-1] = '\0';
PacketBindAdapter(&Status,
GlobalDeviceExtension->NdisProtocolHandle,
&AdapterName,
(PVOID)hDevice, /* special */
NULL);
// Note: If the above usage of the 4'th arg to PacketBindAdapter
// causes problems, use a global variable instead.
if (Status == NDIS_STATUS_SUCCESS || Status == NDIS_STATUS_PENDING) {
*(DWORD *)pDiocParms->lpcbBytesReturned = 1;
return NDIS_STATUS_SUCCESS;
}
break;
case IOCTL_EPACKET_SET_OID:
case IOCTL_EPACKET_QUERY_OID:
if ((Open = GetOpen(hDevice)) != NULL)
return PacketRequest(Open, dwService, dwDDB, hDevice, pDiocParms);
break;
case IOCTL_EPACKET_READ:
if ((Open = GetOpen(hDevice)) != NULL)
return PacketRead(Open, dwDDB, hDevice, pDiocParms);
break;
case IOCTL_EPACKET_WRITE:
if ((Open = GetOpen(hDevice)) != NULL)
return PacketWrite(Open, dwDDB, hDevice, pDiocParms);
break;
}
*(DWORD *)pDiocParms->lpcbBytesReturned = 0;
return NDIS_STATUS_SUCCESS;
}
BOOLEAN PacketAddMulticast( LPADAPTER AdapterObject, LPBYTE address )
{
BOOLEAN Status = FALSE;
LPBYTE p;
int i, count;
LPPACKET lpPacket;
D(bug("PacketAddMulticast\n"));
/*
if(packet_filter & (NDIS_PACKET_TYPE_ALL_MULTICAST|NDIS_PACKET_TYPE_PROMISCUOUS)) {
D(bug("PacketAddMulticast: already listening for all multicast\n"));
return TRUE;
}
*/
lpPacket = PacketQueryOid( AdapterObject, OID_802_3_MULTICAST_LIST, MAX_MULTICAST_SZ );
#define OidData ((PPACKET_OID_DATA)(lpPacket->Buffer))
if(lpPacket) {
count = OidData->Length / ETH_802_3_ADDRESS_LENGTH;
D(bug("PacketAddMulticast: %d old addresses\n",count));
p = (LPBYTE)OidData->Data;
for( i=0; i<count; i++ ) {
if(memcmp(p,address,ETH_802_3_ADDRESS_LENGTH) == 0) {
// This multicast is already defined -- error or not?
Status = TRUE;
D(bug("PacketAddMulticast: address already defined\n"));
break;
}
p += ETH_802_3_ADDRESS_LENGTH;
}
if(i == count) {
if(i >= MAX_MULTICAST) {
D(bug("PacketAddMulticast: too many addresses\n"));
Status = FALSE;
} else {
D(bug("PacketAddMulticast: adding a new address\n"));
// ULONG IoCtlBufferLength = (sizeof(PACKET_OID_DATA)+ETH_802_3_ADDRESS_LENGTH*1-1);
ULONG IoCtlBufferLength = (sizeof(PACKET_OID_DATA)+ETH_802_3_ADDRESS_LENGTH*(count+1)-1);
LPPACKET lpPacket2 = PacketAllocatePacket( AdapterObject, IoCtlBufferLength );
#define OidData2 ((PPACKET_OID_DATA)(lpPacket2->Buffer))
if ( lpPacket2 ) {
OidData2->Oid = OID_802_3_MULTICAST_LIST;
// OidData2->Length = ETH_802_3_ADDRESS_LENGTH*1;
// memcpy( OidData2->Data, address, ETH_802_3_ADDRESS_LENGTH );
memcpy( OidData2->Data, OidData->Data, ETH_802_3_ADDRESS_LENGTH*count );
memcpy( OidData2->Data+ETH_802_3_ADDRESS_LENGTH*count, address, ETH_802_3_ADDRESS_LENGTH );
OidData2->Length = ETH_802_3_ADDRESS_LENGTH*(count+1);
Status = PacketRequest( AdapterObject, lpPacket2, TRUE );
PacketFreePacket( lpPacket2 );
}
#undef OidData2
}
}
PacketFreePacket( lpPacket );
}
#undef OidData
// return Status;
return TRUE;
}
int main(int argc, char* argv[])
{
// Packet.lib variables:
LPADAPTER lpAdapter = 0;
PPACKET_OID_DATA pOidData = malloc( sizeof(PACKET_OID_DATA) + MAX_OID_DATA );
NetType *type = malloc(sizeof(NetType));
UINT speed_Mbps = 0;
BOOL isWinNT = FALSE;
int i;
DWORD dwVersion;
DWORD dwWindowsMajorVersion;
//unicode strings (winnt)
WCHAR AdapterName[8192]; // string that contains a list of the network adapters
WCHAR *temp,*temp1;
//ascii strings (win95)
char AdapterNamea[8192]; // string that contains a list of the network adapters
char *tempa,*temp1a;
int AdapterNum=0,Open;
unsigned long AdapterLength;
FILE * inifile;
char speed_value[10];
char *MAC_value = malloc( 13*sizeof(char) );
char *temp2 = malloc( 13*sizeof(char) );
//interfaceArg specifies the interface # passed fron configchange.pl
//set interfaceArg to argv[1] if arguments are passed
int interfaceArg = 0;
if ( argc>1 && argv[1] )
{
interfaceArg = atoi(argv[1]);
}
// obtain the name of the adapters installed on this machine
//printf("Adapters installed:\n");
i=0;
// the data returned by PacketGetAdapterNames is different in Win95 and in WinNT.
// We have to check the os on which we are running
dwVersion=GetVersion();
dwWindowsMajorVersion = (DWORD)(LOBYTE(LOWORD(dwVersion)));
if (!(dwVersion >= 0x80000000 && dwWindowsMajorVersion >= 4))
{ // Windows NT
isWinNT = TRUE;
AdapterLength=sizeof(AdapterName);
PacketGetAdapterNames((char*)AdapterName,&AdapterLength);
temp=AdapterName;
temp1=AdapterName;
while ((*temp!='\0')||(*(temp-1)!='\0'))
{
if (*temp=='\0')
{
memcpy(AdapterList[i],temp1,(temp-temp1)*2);
temp1=temp+1;
i++;
}
temp++;
}
AdapterNum=i;
// we want to automate the adaptor selection process
// but if there are more than one to choose from, we can't
// so
if (AdapterNum>1)
{
for (i=0;i<AdapterNum;i++)
{
wprintf(L"\n%d- %s\n",i+1,AdapterList[i]);
}
printf("\n");
}
}
else //windows 95
{
AdapterLength=sizeof(AdapterNamea);
PacketGetAdapterNames(AdapterNamea,&AdapterLength);
tempa=AdapterNamea;
temp1a=AdapterNamea;
while ((*tempa!='\0')||(*(tempa-1)!='\0'))
{
if (*tempa=='\0')
{
memcpy(AdapterList[i],temp1a,tempa-temp1a);
temp1a=tempa+1;
i++;
}
tempa++;
}
AdapterNum=i;
// we want to automate the adaptor selection process
// but if there are more than one to choose from, we can't
// so
if (AdapterNum>1)
{
printf("Adapters installed:\n");
for (i=0;i<AdapterNum;i++)
{
printf("\n%d- %s\n",i+1,AdapterList[i]);
}
printf("\n");
}
}
// we want to automate the adaptor selection process
// but if there are more than one to choose from, we can't
// so
//
if (AdapterNum>1)
{
if ( (interfaceArg>AdapterNum)||(interfaceArg<1) )
{
do
{
printf("Select the number of the adapter to use : ");scanf("%d",&Open);
if (Open>AdapterNum) printf("\nThe number must be smaller than %d",AdapterNum);
} while (Open>AdapterNum);
}
else
{
Open = interfaceArg;
}
}
else
{
Open = AdapterNum;
}
lpAdapter = PacketOpenAdapter(AdapterList[Open-1]);
MAC_value[0] = '\0';
temp2[0] = '\0';
speed_value[0] = '\0';
if( NULL != lpAdapter)
{
if ( TRUE == PacketGetNetType (lpAdapter, type) )
{
speed_Mbps = type->LinkSpeed / 1000000; // LinkSpeed is in bits per second
}
else
printf("Could not read Ethernet card's speed\n");
if ( type->LinkType != NdisMedium802_3)
printf("NOT Ethernet802.3 card.\nNetwork Interface not supported\n");
else
{
pOidData->Oid = OID_802_3_CURRENT_ADDRESS;
pOidData->Length = MAX_OID_DATA;
if ( TRUE == PacketRequest(lpAdapter, FALSE , pOidData) )
{
// get info obtained
// printf("Physical address read: ");
/* printf("%x %x %x %x %x %x\n", pOidData->Data[0], pOidData->Data[1],
pOidData->Data[2],pOidData->Data[3],
pOidData->Data[4],pOidData->Data[5]
);*/
pOidData->Data[0] += 2; // changing address from global to local
for( i=0; i<6; i++ )
{
strcpy( temp2, MAC_value);
if( pOidData->Data[i] > 15 )
// has 2 hex digits
sprintf( MAC_value, "%s%x", temp2, pOidData->Data[i]);
else
sprintf( MAC_value, "%s0%x", temp2, pOidData->Data[i]);
}
}
else
printf("Failed to read physical address of Ethernet card\n");
}
free(pOidData);
free(type);
PacketCloseAdapter( lpAdapter );
}
else
{
// lpAdapter NULL
printf("Problem with opening adapter (packet.lib issue)\n");
return (1);
}
inifile = fopen(EPOC_INI_FILE, "a"); // to create if does exist
if ( NULL != inifile )
fclose(inifile);
else
{
printf("Can't create or access %s.\n\n", EPOC_INI_FILE);
return 0;
}
if ( 0 == replace_in_inifile( ETHER_NIF_ENTRY, AdapterList[Open-1], isWinNT ) )
printf( "Netcards using adapter %d\n", Open );
else
{
return 0;
}
if ( 0 != replace_in_inifile( ETHER_MAC_ENTRY, MAC_value, FALSE ) )
{
printf("Couldn't write MAC address to %s file\n", EPOC_INI_FILE);
return (1);
}
if( 0 != speed_Mbps )
sprintf( speed_value, "%dMbps", speed_Mbps);
if ( 0 != replace_in_inifile( ETHER_SPEED_ENTRY, speed_value, FALSE ) )
{
printf("Couldn't write speed value to %s file\n", EPOC_INI_FILE);
return (1);
}
//printf("Netcards has written settings to %s.\n\n", EPOC_INI_FILE);
free(MAC_value);
free(temp2);
return (0);
}
int main()
{
LPADAPTER lpAdapter = 0;
int i;
DWORD dwErrorCode;
char AdapterName[8192];
char *temp,*temp1;
int AdapterNum=0,Open;
ULONG AdapterLength;
PPACKET_OID_DATA OidData;
BOOLEAN Status;
//
// Obtain the name of the adapters installed on this machine
//
printf("Packet.dll test application. Library version:%s\n", PacketGetVersion());
printf("Adapters installed:\n");
i=0;
AdapterLength = sizeof(AdapterName);
if(PacketGetAdapterNames(AdapterName,&AdapterLength)==FALSE){
printf("Unable to retrieve the list of the adapters!\n");
return -1;
}
temp=AdapterName;
temp1=AdapterName;
while ((*temp!='\0')||(*(temp-1)!='\0'))
{
if (*temp=='\0')
{
memcpy(AdapterList[i],temp1,temp-temp1);
temp1=temp+1;
i++;
}
temp++;
}
AdapterNum=i;
for (i=0;i<AdapterNum;i++)
printf("\n%d- %s\n",i+1,AdapterList[i]);
printf("\n");
do
{
printf("Select the number of the adapter to open : ");
scanf_s("%d",&Open);
if (Open>AdapterNum) printf("\nThe number must be smaller than %d",AdapterNum);
} while (Open>AdapterNum);
//
// Open the selected adapter
//
lpAdapter = PacketOpenAdapter(AdapterList[Open-1]);
if (!lpAdapter || (lpAdapter->hFile == INVALID_HANDLE_VALUE))
{
dwErrorCode=GetLastError();
printf("Unable to open the adapter, Error Code : %lx\n",dwErrorCode);
return -1;
}
//
// Allocate a buffer to get the MAC adress
//
OidData = malloc(6 + sizeof(PACKET_OID_DATA));
if (OidData == NULL)
{
printf("error allocating memory!\n");
PacketCloseAdapter(lpAdapter);
return -1;
}
//
// Retrieve the adapter MAC querying the NIC driver
//
OidData->Oid = OID_802_3_CURRENT_ADDRESS;
OidData->Length = 6;
ZeroMemory(OidData->Data, 6);
Status = PacketRequest(lpAdapter, FALSE, OidData);
if(Status)
{
printf("The MAC address of the adapter is %.2x:%.2x:%.2x:%.2x:%.2x:%.2x\n",
(OidData->Data)[0],
(OidData->Data)[1],
(OidData->Data)[2],
(OidData->Data)[3],
(OidData->Data)[4],
(OidData->Data)[5]);
}
else
{
printf("error retrieving the MAC address of the adapter!\n");
}
free(OidData);
PacketCloseAdapter(lpAdapter);
return (0);
}
BOOLEAN PacketGetAdapterNames (PTSTR pStr,
PULONG BufferSize)
{
ULONG Result,i;
LONG Status;
char* pStrInternal;
ULONG RemainingBytes;
LPADAPTER adapter;
PPACKET_OID_DATA OidData;
HKEY Key;
char NdisName[80];
ULONG NeededBytes;
ULONG NeededBytesForString;
char TempBuffer[1024];
BOOLEAN retVal;
OidData=GlobalAllocPtr(GMEM_MOVEABLE | GMEM_ZEROINIT,256);
if (OidData == NULL)
{
return FALSE;
}
Status=RegOpenKeyEx(HKEY_LOCAL_MACHINE,"SYSTEM\\CurrentControlSet\\Services\\class\\net",0,KEY_READ,&Key);
if (Status != ERROR_SUCCESS)
{
GlobalFree(OidData);
return FALSE;
}
NeededBytes = 0;
//first we calculate the needed bytes
i=0;
while((Result=RegEnumKey(Key,i,NdisName,sizeof(NdisName) - sizeof("\\NDIS") - 1))==ERROR_SUCCESS)
{
HKEY hKeyNdisName;
strcat(NdisName,"\\NDIS");
Status=RegOpenKeyEx(Key,NdisName,0,KEY_READ,&hKeyNdisName);
if (Status != ERROR_SUCCESS)
{
i++;
continue;
}
//we need to tell RegOpenKeyEx the length of the buffer passed as argument
NeededBytesForString = sizeof(TempBuffer);
Status=RegQueryValueEx(hKeyNdisName,"LOGDRIVERNAME",NULL,NULL,(LPBYTE)TempBuffer,&NeededBytesForString);
if (Status != ERROR_SUCCESS)
{
RegCloseKey(hKeyNdisName);
i++;
continue;
}
NeededBytes += NeededBytesForString;
//we try to open the adapter and retrieve its name
adapter=PacketOpenAdapter(TempBuffer);
if(adapter==NULL)
{
NeededBytes += sizeof("Unknown") + 1;
}
else
{
//we retrieve its name by performing a PacketRequest,
//the buffer that will contain the name is at the end of the OidData structure
OidData->Oid = OID_GEN_VENDOR_DESCRIPTION;
OidData->Length = 256 - sizeof(PACKET_OID_DATA);
Status = PacketRequest(adapter,FALSE,OidData);
if(Status==0)
{
NeededBytes += sizeof("Unknown") + 1;
}
else
{
NeededBytes += strlen((char*) OidData->Data) + 1;
}
PacketCloseAdapter(adapter);
}
i++;
RegCloseKey(hKeyNdisName);
}
NeededBytes += 1 + 1; //the two nulls at the end of each block of strings
if (NeededBytes > *BufferSize || pStr == NULL || Result != ERROR_NO_MORE_ITEMS)
{
*BufferSize = NeededBytes;
GlobalFree(OidData);
RegCloseKey(Key);
SetLastError(ERROR_INSUFFICIENT_BUFFER);
return FALSE;
}
//now we copy the strings
retVal = TRUE;
NeededBytes = 0;
i = 0;
pStrInternal = pStr;
RemainingBytes = *BufferSize;
while((Result=RegEnumKey(Key,i,NdisName,sizeof(NdisName) - sizeof("\\NDIS") - 1))==ERROR_SUCCESS)
{
HKEY hKeyNdisName;
strcat(NdisName,"\\NDIS");
NeededBytesForString = sizeof(TempBuffer);
Status=RegOpenKeyEx(Key,NdisName,0,KEY_READ,&hKeyNdisName);
if (Status != ERROR_SUCCESS)
{
i++;
continue;
}
Status=RegQueryValueEx(hKeyNdisName,"LOGDRIVERNAME",NULL,NULL,(LPBYTE)TempBuffer,&NeededBytesForString);
if (Status == ERROR_SUCCESS && NeededBytesForString <= RemainingBytes)
{
//this copy is safe, since we have checked that the available space will fit the string
strcpy(pStrInternal, TempBuffer);
pStrInternal += NeededBytesForString;
RemainingBytes -= NeededBytesForString;
}
NeededBytes += NeededBytesForString; //just in case the second scan returns a larger number of adapters!!
i++;
RegCloseKey(hKeyNdisName);
}
RegCloseKey(Key);
//we need to properly terminate the list of adapter names with another \0
if (RemainingBytes > 0)
{
pStrInternal[0] = 0;
pStrInternal++;
RemainingBytes--;
}
NeededBytes++;
while (*pStr != 0) //now we scan again the list of adapters in pStr to retrieve their names
{
adapter=PacketOpenAdapter(pStr);
if(adapter==NULL)
{
if ( RemainingBytes < sizeof("Unknown") + 1 )
retVal = FALSE; //we do not copy anything, we simply skip this adapter, and return failure
else
{ //this copy is safe as we have checked that the remaining bytes will fit the source string
strcpy(pStrInternal, "Unknown");
//we move the pointer of the list of adapter names
pStrInternal += sizeof("Unknown") + 1;
RemainingBytes -= sizeof("Unknown") + 1;
}
//we continue to keep track of available bytes. This is used if we fail in this phase
NeededBytes += sizeof("Unknown") + 1;
}
else
{
OidData->Oid = OID_GEN_VENDOR_DESCRIPTION;
OidData->Length = 256 - sizeof(PACKET_OID_DATA);
Status = PacketRequest(adapter,FALSE,OidData);
if(Status==0)
{
if ( RemainingBytes < sizeof("Unknown") + 1 )
retVal = FALSE; //we do not copy anything, we simply skip this adapter, and return failure
else
{ //this copy is safe as we have checked that the remaining bytes will fit the source string
strcpy(pStrInternal, "Unknown");
//we move the pointer of the list of adapter names
pStrInternal += sizeof("Unknown") + 1;
RemainingBytes -= sizeof("Unknown") + 1;
}
//we continue to keep track of available bytes. This is used if we fail in this phase
NeededBytes += sizeof("Unknown") + 1;
}
else
{
if ( RemainingBytes < strlen((char*) OidData->Data) + 1 )
retVal = FALSE; //we do not copy anything, we simply skip this adapter, and return failure
else
{
//this copy is safe as we have checked that the remaining bytes will fit the source string
strcpy(pStrInternal, (char*)OidData->Data);
//we move the pointer of the list of adapter names
pStrInternal += strlen((char*) OidData->Data) + 1;
RemainingBytes -= strlen((char*) OidData->Data) + 1;
}
//we continue to keep track of available bytes. This is used if we fail in this phase
NeededBytes += strlen((char*) OidData->Data) + 1;
}
PacketCloseAdapter(adapter);
}
//we move to the next adapter in the list. We end when we reach the double \0
pStr += strlen(pStr) + 1;
}
//we need to properly terminate the list of adapter descriptions with another \0
if (RemainingBytes > 0)
{
pStrInternal[0] = 0;
pStrInternal++;
RemainingBytes--;
}
else
retVal = FALSE;
NeededBytes++;
*BufferSize = NeededBytes;
GlobalFree(OidData);
return retVal;
}
struct netdriverdata *uaenet_enumerate (struct netdriverdata **out, const TCHAR *name)
{
static int done;
char errbuf[PCAP_ERRBUF_SIZE];
pcap_if_t *alldevs, *d;
int cnt;
HMODULE hm;
LPADAPTER lpAdapter = 0;
PPACKET_OID_DATA OidData;
struct netdriverdata *tc, *tcp;
pcap_t *fp;
int val;
TCHAR *ss;
if (enumerated) {
if (out)
*out = tds;
return enumit (name);
}
tcp = tds;
hm = LoadLibrary (L"wpcap.dll");
if (hm == NULL) {
write_log (L"uaenet: winpcap not installed (wpcap.dll)\n");
return NULL;
}
FreeLibrary (hm);
hm = LoadLibrary (L"packet.dll");
if (hm == NULL) {
write_log (L"uaenet: winpcap not installed (packet.dll)\n");
return NULL;
}
FreeLibrary (hm);
if (!isdllversion (L"wpcap.dll", 4, 0, 0, 0)) {
write_log (L"uaenet: too old winpcap, v4 or newer required\n");
return NULL;
}
ss = au (pcap_lib_version ());
if (!done)
write_log (L"uaenet: %s\n", ss);
xfree (ss);
if (pcap_findalldevs_ex (PCAP_SRC_IF_STRING, NULL, &alldevs, errbuf) == -1) {
ss = au (errbuf);
write_log (L"uaenet: failed to get interfaces: %s\n", ss);
xfree (ss);
return NULL;
}
if (!done)
write_log (L"uaenet: detecting interfaces\n");
for(cnt = 0, d = alldevs; d != NULL; d = d->next) {
char *n2;
TCHAR *ss2;
tc = tcp + cnt;
if (cnt >= MAX_TOTAL_NET_DEVICES) {
write_log (L"buffer overflow\n");
break;
}
ss = au (d->name);
ss2 = d->description ? au (d->description) : L"(no description)";
write_log (L"%s\n- %s\n", ss, ss2);
xfree (ss2);
xfree (ss);
n2 = d->name;
if (strlen (n2) <= strlen (PCAP_SRC_IF_STRING)) {
write_log (L"- corrupt name\n");
continue;
}
fp = pcap_open (d->name, 65536, 0, 0, NULL, errbuf);
if (!fp) {
ss = au (errbuf);
write_log (L"- pcap_open() failed: %s\n", ss);
xfree (ss);
continue;
}
val = pcap_datalink (fp);
pcap_close (fp);
if (val != DLT_EN10MB) {
if (!done)
write_log (L"- not an ethernet adapter (%d)\n", val);
continue;
}
lpAdapter = PacketOpenAdapter (n2 + strlen (PCAP_SRC_IF_STRING));
if (lpAdapter == NULL) {
if (!done)
write_log (L"- PacketOpenAdapter() failed\n");
continue;
}
OidData = (PPACKET_OID_DATA)xcalloc (uae_u8, 6 + sizeof(PACKET_OID_DATA));
if (OidData) {
OidData->Length = 6;
OidData->Oid = OID_802_3_CURRENT_ADDRESS;
if (PacketRequest (lpAdapter, FALSE, OidData)) {
memcpy (tc->mac, OidData->Data, 6);
if (!done)
write_log (L"- MAC %02X:%02X:%02X:%02X:%02X:%02X (%d)\n",
tc->mac[0], tc->mac[1], tc->mac[2],
tc->mac[3], tc->mac[4], tc->mac[5], cnt++);
tc->active = 1;
tc->mtu = 1522;
tc->name = au (d->name);
tc->desc = au (d->description);
} else {
write_log (L" - failed to get MAC\n");
}
xfree (OidData);
}
PacketCloseAdapter (lpAdapter);
}
if (!done)
write_log (L"uaenet: end of detection\n");
done = 1;
pcap_freealldevs (alldevs);
enumerated = 1;
if (out)
*out = tds;
return enumit (name);
}
bool ethernet_init(
char *if_name)
{
PPACKET_OID_DATA pOidData;
LPADAPTER lpAdapter;
pcap_if_t *pcap_all_if;
pcap_if_t *dev;
BOOLEAN result;
CHAR str[sizeof(PACKET_OID_DATA) + 128];
int i;
char msgBuf[200];
if (ethernet_valid())
ethernet_cleanup();
/**
* Find the interface user specified
*/
/* Retrieve the device list */
if (pcap_findalldevs(&pcap_all_if, pcap_errbuf) == -1) {
sprintf(msgBuf, "ethernet.c: error in pcap_findalldevs: %s\n",
pcap_errbuf);
LogError(msgBuf);
return false;
}
/* Scan the list printing every entry */
for (dev = pcap_all_if; dev; dev = dev->next) {
if (strcmp(if_name, dev->name) == 0)
break;
}
pcap_freealldevs(pcap_all_if); /* we don't need it anymore */
if (dev == NULL) {
sprintf(msgBuf, "ethernet.c: specified interface not found: %s\n",
if_name);
LogError(msgBuf);
return false;
}
/**
* Get local MAC address
*/
ZeroMemory(str, sizeof(PACKET_OID_DATA) + 128);
lpAdapter = PacketOpenAdapter(if_name);
if (lpAdapter == NULL) {
ethernet_cleanup();
sprintf(msgBuf, "ethernet.c: error in PacketOpenAdapter(\"%s\")\n",
if_name);
LogError(msgBuf);
return false;
}
pOidData = (PPACKET_OID_DATA) str;
pOidData->Oid = OID_802_3_CURRENT_ADDRESS;
pOidData->Length = 6;
result = PacketRequest(lpAdapter, FALSE, pOidData);
if (!result) {
PacketCloseAdapter(lpAdapter);
ethernet_cleanup();
LogError("ethernet.c: error in PacketRequest()\n");
return false;
}
for (i = 0; i < 6; ++i)
Ethernet_MAC_Address[i] = pOidData->Data[i];
PacketCloseAdapter(lpAdapter);
/**
* Open interface for subsequent sending and receiving
*/
/* Open the output device */
pcap_eth802_fp = pcap_open(if_name, /* name of the device */
MAX_MPDU, /* portion of the packet to capture */
PCAP_OPENFLAG_PROMISCUOUS, /* promiscuous mode */
eth_timeout, /* read timeout */
NULL, /* authentication on the remote machine */
pcap_errbuf /* error buffer */
);
if (pcap_eth802_fp == NULL) {
PacketCloseAdapter(lpAdapter);
ethernet_cleanup();
sprintf(msgBuf,
"ethernet.c: unable to open the adapter. %s is not supported by WinPcap\n",
if_name);
LogError(msgBuf);
return false;
}
LogInfo("ethernet.c: ethernet_init() ok.\n");
atexit(ethernet_cleanup);
return ethernet_valid();
}
